@tpitre/story-ui 2.2.0 → 2.3.1

package/dist/story-generator/imageProcessor.js

@@ -0,0 +1,391 @@
+/**
+ * Image Processing Module for StoryUI Vision Feature
+ *
+ * This module handles all image processing operations including:
+ * - Validation of image inputs (size, format, data integrity)
+ * - Conversion between different image formats (URL, base64, buffer)
+ * - Media type detection from magic bytes and file extensions
+ * - Preparation of images for LLM provider consumption
+ *
+ * Supports: PNG, JPEG, GIF, WebP formats
+ * Max size: 20MB for base64 encoded images
+ */
+import { logger } from './logger.js';
+// Maximum image size in bytes (20MB)
+const MAX_IMAGE_SIZE_BYTES = 20 * 1024 * 1024;
+// Size warning threshold (5MB)
+const SIZE_WARNING_THRESHOLD = 5 * 1024 * 1024;
+// Supported MIME types
+const SUPPORTED_MEDIA_TYPES = [
+    'image/png',
+    'image/jpeg',
+    'image/jpg',
+    'image/gif',
+    'image/webp',
+];
+// Magic bytes for image format detection
+const MAGIC_BYTES = {
+    png: { bytes: [0x89, 0x50, 0x4e, 0x47], type: 'image/png' },
+    jpeg: { bytes: [0xff, 0xd8, 0xff], type: 'image/jpeg' },
+    gif87a: { bytes: [0x47, 0x49, 0x46, 0x38, 0x37, 0x61], type: 'image/gif' },
+    gif89a: { bytes: [0x47, 0x49, 0x46, 0x38, 0x39, 0x61], type: 'image/gif' },
+    webp: { bytes: [0x52, 0x49, 0x46, 0x46], type: 'image/webp' }, // RIFF header (WebP also has WEBP at offset 8)
+};
+// File extension to MIME type mapping
+const EXTENSION_TO_MIME = {
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+};
+/**
+ * Get media type from buffer by checking magic bytes
+ *
+ * @param buffer - Image buffer to analyze
+ * @returns Detected MIME type or undefined if not recognized
+ */
+export function getMediaTypeFromBuffer(buffer) {
+    // Check each magic byte signature
+    for (const [format, { bytes, type }] of Object.entries(MAGIC_BYTES)) {
+        if (buffer.length < bytes.length)
+            continue;
+        // Compare the first N bytes
+        const matches = bytes.every((byte, index) => buffer[index] === byte);
+        if (matches) {
+            // Special case for WebP: verify WEBP signature at offset 8
+            if (format === 'webp') {
+                if (buffer.length < 12)
+                    continue;
+                const webpSignature = buffer.slice(8, 12).toString('ascii');
+                if (webpSignature === 'WEBP') {
+                    logger.debug(`Detected image format from magic bytes: ${type}`);
+                    return type;
+                }
+                continue;
+            }
+            logger.debug(`Detected image format from magic bytes: ${type}`);
+            return type;
+        }
+    }
+    logger.warn('Unable to detect image format from magic bytes');
+    return undefined;
+}
+/**
+ * Get media type from URL file extension
+ *
+ * @param url - URL to extract extension from
+ * @returns MIME type or undefined if not recognized
+ */
+function getMediaTypeFromUrl(url) {
+    try {
+        const urlObj = new URL(url);
+        const pathname = urlObj.pathname.toLowerCase();
+        const extension = pathname.split('.').pop();
+        if (extension && EXTENSION_TO_MIME[extension]) {
+            const mediaType = EXTENSION_TO_MIME[extension];
+            logger.debug(`Detected media type from URL extension: ${mediaType}`);
+            return mediaType;
+        }
+    }
+    catch (error) {
+        logger.warn(`Failed to parse URL for media type detection: ${url}`);
+    }
+    return undefined;
+}
+/**
+ * Normalize base64 data by removing data URI prefix if present
+ *
+ * @param data - Base64 string (with or without data URI prefix)
+ * @returns Pure base64 string without prefix
+ */
+function normalizeBase64(data) {
+    // Remove data URI prefix if present (e.g., "data:image/png;base64,")
+    const dataUriPattern = /^data:([^;]+);base64,/;
+    const match = data.match(dataUriPattern);
+    if (match) {
+        logger.debug(`Removing data URI prefix: ${match[1]}`);
+        return data.replace(dataUriPattern, '');
+    }
+    return data;
+}
+/**
+ * Extract media type from data URI prefix if present
+ *
+ * @param data - Base64 string that may contain data URI prefix
+ * @returns Media type from prefix or undefined
+ */
+function extractMediaTypeFromDataUri(data) {
+    const dataUriPattern = /^data:([^;]+);base64,/;
+    const match = data.match(dataUriPattern);
+    if (match) {
+        const mediaType = match[1].toLowerCase();
+        if (SUPPORTED_MEDIA_TYPES.includes(mediaType)) {
+            logger.debug(`Extracted media type from data URI: ${mediaType}`);
+            return mediaType;
+        }
+    }
+    return undefined;
+}
+/**
+ * Validate an image input
+ *
+ * Checks:
+ * - Has either data or url
+ * - File size is within limits
+ * - Media type is supported
+ * - Base64 data is valid
+ *
+ * @param image - Image input to validate
+ * @returns Validation result with error/warning messages
+ */
+export function validateImage(image) {
+    const name = image.name || 'unknown';
+    // Check that either data or url is provided
+    if (!image.data && !image.url) {
+        return {
+            valid: false,
+            error: `Image "${name}" must have either 'data' or 'url' property`,
+        };
+    }
+    // Both data and url provided - prefer data
+    if (image.data && image.url) {
+        logger.warn(`Image "${name}" has both data and url, will use data`);
+    }
+    // Validate media type if provided
+    if (image.mediaType) {
+        const mediaType = image.mediaType.toLowerCase();
+        if (!SUPPORTED_MEDIA_TYPES.includes(mediaType)) {
+            return {
+                valid: false,
+                error: `Unsupported media type "${mediaType}". Supported types: ${SUPPORTED_MEDIA_TYPES.join(', ')}`,
+            };
+        }
+    }
+    // Validate base64 data if provided
+    if (image.data) {
+        try {
+            const normalizedData = normalizeBase64(image.data);
+            // Check if valid base64
+            const base64Pattern = /^[A-Za-z0-9+/]*={0,2}$/;
+            if (!base64Pattern.test(normalizedData)) {
+                return {
+                    valid: false,
+                    error: `Invalid base64 data for image "${name}"`,
+                };
+            }
+            // Calculate decoded size
+            const padding = (normalizedData.match(/=/g) || []).length;
+            const sizeBytes = (normalizedData.length * 3 / 4) - padding;
+            logger.debug(`Image "${name}" size: ${(sizeBytes / 1024 / 1024).toFixed(2)}MB`);
+            // Check size limits
+            if (sizeBytes > MAX_IMAGE_SIZE_BYTES) {
+                return {
+                    valid: false,
+                    error: `Image "${name}" exceeds maximum size of ${MAX_IMAGE_SIZE_BYTES / 1024 / 1024}MB (size: ${(sizeBytes / 1024 / 1024).toFixed(2)}MB)`,
+                };
+            }
+            // Warn about large images
+            if (sizeBytes > SIZE_WARNING_THRESHOLD) {
+                return {
+                    valid: true,
+                    warning: `Image "${name}" is large (${(sizeBytes / 1024 / 1024).toFixed(2)}MB). Consider optimizing for better performance.`,
+                };
+            }
+        }
+        catch (error) {
+            return {
+                valid: false,
+                error: `Failed to validate base64 data for image "${name}": ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    // If URL is provided and no data, we can't validate size until fetch
+    if (image.url && !image.data) {
+        try {
+            // Basic URL validation
+            new URL(image.url);
+        }
+        catch (error) {
+            return {
+                valid: false,
+                error: `Invalid URL for image "${name}": ${image.url}`,
+            };
+        }
+    }
+    return { valid: true };
+}
+/**
+ * Fetch an image from a URL and convert to base64
+ *
+ * @param url - URL to fetch image from
+ * @returns Object containing base64 data and detected media type
+ * @throws Error if fetch fails or image is invalid
+ */
+export async function fetchImageAsBase64(url) {
+    logger.info(`Fetching image from URL: ${url}`);
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        // Get content type from response headers
+        const contentType = response.headers.get('content-type')?.toLowerCase();
+        logger.debug(`Response content-type: ${contentType}`);
+        // Get the image buffer
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        // Check size
+        if (buffer.length > MAX_IMAGE_SIZE_BYTES) {
+            throw new Error(`Image exceeds maximum size of ${MAX_IMAGE_SIZE_BYTES / 1024 / 1024}MB (size: ${(buffer.length / 1024 / 1024).toFixed(2)}MB)`);
+        }
+        // Detect media type (priority: magic bytes > content-type header > URL extension)
+        let mediaType = getMediaTypeFromBuffer(buffer);
+        if (!mediaType && contentType && SUPPORTED_MEDIA_TYPES.includes(contentType)) {
+            mediaType = contentType;
+            logger.debug(`Using media type from content-type header: ${mediaType}`);
+        }
+        if (!mediaType) {
+            mediaType = getMediaTypeFromUrl(url);
+        }
+        if (!mediaType) {
+            throw new Error('Unable to determine image media type from URL, headers, or content');
+        }
+        // Convert to base64
+        const base64Data = buffer.toString('base64');
+        logger.info(`Successfully fetched and encoded image: ${(buffer.length / 1024).toFixed(2)}KB, type: ${mediaType}`);
+        return {
+            data: base64Data,
+            mediaType,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`Failed to fetch image from URL ${url}: ${errorMessage}`);
+        throw new Error(`Failed to fetch image: ${errorMessage}`);
+    }
+}
+/**
+ * Process a single image input into the internal ProcessedImage format
+ *
+ * @param image - Image input to process
+ * @returns Processed image with validated data and media type
+ * @throws Error if processing fails
+ */
+async function processSingleImage(image) {
+    const name = image.name || 'unknown';
+    logger.debug(`Processing image: ${name}`);
+    // Validate image first
+    const validation = validateImage(image);
+    if (!validation.valid) {
+        throw new Error(validation.error || 'Image validation failed');
+    }
+    // Log warnings
+    if (validation.warning) {
+        logger.warn(validation.warning);
+    }
+    let data;
+    let mediaType;
+    // Process based on input type
+    if (image.data) {
+        // Extract media type from data URI if present
+        mediaType = extractMediaTypeFromDataUri(image.data);
+        // Normalize base64 data (remove data URI prefix)
+        data = normalizeBase64(image.data);
+        // If no media type from data URI, try to detect from base64 data
+        if (!mediaType) {
+            const buffer = Buffer.from(data, 'base64');
+            mediaType = getMediaTypeFromBuffer(buffer);
+        }
+        // Use provided media type as fallback
+        if (!mediaType && image.mediaType) {
+            const providedType = image.mediaType.toLowerCase();
+            if (SUPPORTED_MEDIA_TYPES.includes(providedType)) {
+                mediaType = providedType;
+                logger.debug(`Using provided media type: ${mediaType}`);
+            }
+        }
+        if (!mediaType) {
+            throw new Error(`Unable to determine media type for image "${name}". Please provide mediaType property.`);
+        }
+    }
+    else if (image.url) {
+        // Fetch image from URL
+        const fetched = await fetchImageAsBase64(image.url);
+        data = fetched.data;
+        mediaType = fetched.mediaType;
+        // Override with provided media type if specified
+        if (image.mediaType) {
+            const providedType = image.mediaType.toLowerCase();
+            if (SUPPORTED_MEDIA_TYPES.includes(providedType)) {
+                logger.debug(`Overriding detected media type ${mediaType} with provided type ${providedType}`);
+                mediaType = providedType;
+            }
+        }
+    }
+    else {
+        throw new Error(`Image "${name}" must have either 'data' or 'url' property`);
+    }
+    logger.info(`Successfully processed image "${name}": ${mediaType}`);
+    return {
+        data,
+        mediaType,
+        name: image.name,
+    };
+}
+/**
+ * Convert processed images to ImageContent format for LLM providers
+ *
+ * @param processed - Array of processed images
+ * @returns Array of ImageContent objects ready for LLM consumption
+ */
+function convertToImageContent(processed) {
+    return processed.map(img => ({
+        type: 'image',
+        source: {
+            type: 'base64',
+            mediaType: img.mediaType,
+            data: img.data,
+        },
+    }));
+}
+/**
+ * Process multiple image inputs and convert to ImageContent format
+ *
+ * This is the main entry point for image processing. It:
+ * 1. Validates each image input
+ * 2. Fetches URL images and converts to base64
+ * 3. Detects media types from magic bytes, headers, or extensions
+ * 4. Returns array of ImageContent objects ready for LLM providers
+ *
+ * @param images - Array of image inputs to process
+ * @returns Promise resolving to array of ImageContent objects
+ * @throws Error if any image fails to process
+ */
+export async function processImageInputs(images) {
+    if (!images || images.length === 0) {
+        logger.debug('No images to process');
+        return [];
+    }
+    logger.info(`Processing ${images.length} image(s)`);
+    try {
+        // Process all images (can be done in parallel for better performance)
+        const processed = await Promise.all(images.map((img, index) => {
+            // Add index to name for better error messages if name not provided
+            const imageWithName = {
+                ...img,
+                name: img.name || `image-${index + 1}`,
+            };
+            return processSingleImage(imageWithName);
+        }));
+        // Convert to ImageContent format
+        const imageContents = convertToImageContent(processed);
+        logger.info(`Successfully processed ${imageContents.length} image(s)`);
+        return imageContents;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`Failed to process images: ${errorMessage}`);
+        throw new Error(`Image processing failed: ${errorMessage}`);
+    }
+}

package/dist/story-generator/inMemoryStoryService.d.ts

@@ -0,0 +1,89 @@
+import { StoryUIConfig } from '../story-ui.config.js';
+/**
+ * In-memory story service for production environments
+ * Stores generated stories in memory and serves them via API
+ */
+export declare class InMemoryStoryService {
+    private stories;
+    private config;
+    constructor(config: StoryUIConfig);
+    /**
+     * Stores a generated story in memory
+     */
+    storeStory(story: GeneratedStory): void;
+    /**
+     * Retrieves a story by ID
+     */
+    getStory(id: string): GeneratedStory | null;
+    /**
+     * Gets all stored stories
+     */
+    getAllStories(): GeneratedStory[];
+    /**
+     * Deletes a story by ID
+     */
+    deleteStory(id: string): boolean;
+    /**
+     * Clears all stories
+     */
+    clearAllStories(): void;
+    /**
+     * Gets story content for Storybook integration
+     */
+    getStoryContent(id: string): string | null;
+    /**
+     * Gets story metadata for listing
+     */
+    getStoryMetadata(): StoryMetadata[];
+    /**
+     * Cleans up old stories to prevent memory leaks
+     */
+    private cleanupOldStories;
+    /**
+     * Counts components used in a story
+     */
+    private countComponents;
+    /**
+     * Gets memory usage statistics
+     */
+    getMemoryStats(): MemoryStats;
+}
+/**
+ * Generated story interface
+ */
+export interface GeneratedStory {
+    id: string;
+    title: string;
+    description: string;
+    content: string;
+    createdAt: Date;
+    lastAccessed: Date;
+    prompt?: string;
+    components?: string[];
+}
+/**
+ * Story metadata for listing
+ */
+export interface StoryMetadata {
+    id: string;
+    title: string;
+    description: string;
+    createdAt: Date;
+    lastAccessed: Date;
+    componentCount: number;
+}
+/**
+ * Memory usage statistics
+ */
+export interface MemoryStats {
+    storyCount: number;
+    totalSizeBytes: number;
+    averageSizeBytes: number;
+    oldestStory: Date | null;
+    newestStory: Date | null;
+}
+/**
+ * Gets or creates the global story service instance
+ */
+export declare function getInMemoryStoryService(config: StoryUIConfig): InMemoryStoryService;
+//# sourceMappingURL=inMemoryStoryService.d.ts.map

package/dist/story-generator/inMemoryStoryService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inMemoryStoryService.d.ts","sourceRoot":"","sources":["../../story-generator/inMemoryStoryService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD;;;GAGG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,OAAO,CAA0C;IACzD,OAAO,CAAC,MAAM,CAAgB;gBAElB,MAAM,EAAE,aAAa;IAIjC;;OAEG;IACH,UAAU,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAWvC;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAS3C;;OAEG;IACH,aAAa,IAAI,cAAc,EAAE;IAMjC;;OAEG;IACH,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIhC;;OAEG;IACH,eAAe,IAAI,IAAI;IAIvB;;OAEG;IACH,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAK1C;;OAEG;IACH,gBAAgB,IAAI,aAAa,EAAE;IAWnC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAwBzB;;OAEG;IACH,OAAO,CAAC,eAAe;IAKvB;;OAEG;IACH,cAAc,IAAI,WAAW;CAgB9B;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,YAAY,EAAE,IAAI,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,IAAI,CAAC;IAChB,YAAY,EAAE,IAAI,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,IAAI,GAAG,IAAI,CAAC;IACzB,WAAW,EAAE,IAAI,GAAG,IAAI,CAAC;CAC1B;AAOD;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,aAAa,GAAG,oBAAoB,CAKnF"}

package/dist/story-generator/llm-providers/base-provider.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Base LLM Provider
+ *
+ * Abstract base class for LLM providers with shared functionality.
+ */
+import { LLMProvider, ProviderType, ProviderConfig, ModelInfo, ChatMessage, ChatOptions, ChatResponse, StreamChunk, ImageContent, ImageAnalysis, ValidationResult } from './types.js';
+export declare abstract class BaseLLMProvider implements LLMProvider {
+    abstract readonly name: string;
+    abstract readonly type: ProviderType;
+    abstract readonly supportedModels: ModelInfo[];
+    protected config: ProviderConfig;
+    constructor(config?: Partial<ProviderConfig>);
+    /**
+     * Called after construction to set the provider type
+     * Subclasses should call this in their constructor after super()
+     */
+    protected setProviderType(): void;
+    abstract chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse>;
+    abstract validateApiKey(apiKey: string): Promise<ValidationResult>;
+    supportsVision(): boolean;
+    supportsDocuments(): boolean;
+    supportsFunctionCalling(): boolean;
+    supportsStreaming(): boolean;
+    configure(config: ProviderConfig): void;
+    getConfig(): ProviderConfig;
+    isConfigured(): boolean;
+    protected getSelectedModel(): ModelInfo | undefined;
+    protected validateMessages(messages: ChatMessage[]): void;
+    protected buildSystemPrompt(options?: ChatOptions): string | undefined;
+    chatStream(messages: ChatMessage[], options?: ChatOptions): AsyncIterable<StreamChunk>;
+    analyzeImage(image: ImageContent, prompt?: string): Promise<ImageAnalysis>;
+    estimateTokens(text: string): number;
+    protected logRequest(messages: ChatMessage[], options?: ChatOptions): void;
+    protected logResponse(response: ChatResponse): void;
+}
+//# sourceMappingURL=base-provider.d.ts.map

package/dist/story-generator/llm-providers/base-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-provider.d.ts","sourceRoot":"","sources":["../../../story-generator/llm-providers/base-provider.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,WAAW,EACX,YAAY,EACZ,cAAc,EACd,SAAS,EACT,WAAW,EACX,WAAW,EACX,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,aAAa,EACb,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAGpB,8BAAsB,eAAgB,YAAW,WAAW;IAC1D,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IACrC,QAAQ,CAAC,QAAQ,CAAC,eAAe,EAAE,SAAS,EAAE,CAAC;IAE/C,SAAS,CAAC,MAAM,EAAE,cAAc,CAAC;gBAErB,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC;IAU5C;;;OAGG;IACH,SAAS,CAAC,eAAe,IAAI,IAAI;IAKjC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IACpF,QAAQ,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAGlE,cAAc,IAAI,OAAO;IAKzB,iBAAiB,IAAI,OAAO;IAK5B,uBAAuB,IAAI,OAAO;IAKlC,iBAAiB,IAAI,OAAO;IAM5B,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAQvC,SAAS,IAAI,cAAc;IAI3B,YAAY,IAAI,OAAO;IAKvB,SAAS,CAAC,gBAAgB,IAAI,SAAS,GAAG,SAAS;IAInD,SAAS,CAAC,gBAAgB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,IAAI;IAYzD,SAAS,CAAC,iBAAiB,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS;IAK/D,UAAU,CACf,QAAQ,EAAE,WAAW,EAAE,EACvB,OAAO,CAAC,EAAE,WAAW,GACpB,aAAa,CAAC,WAAW,CAAC;IAqBvB,YAAY,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IA2BhF,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAMpC,SAAS,CAAC,UAAU,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI;IAQ1E,SAAS,CAAC,WAAW,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI;CAOpD"}

package/dist/story-generator/llm-providers/base-provider.js

@@ -0,0 +1,135 @@
+/**
+ * Base LLM Provider
+ *
+ * Abstract base class for LLM providers with shared functionality.
+ */
+import { logger } from '../logger.js';
+export class BaseLLMProvider {
+    constructor(config) {
+        // Note: provider type will be set by subclass after construction
+        this.config = {
+            provider: 'custom', // Placeholder, will be set when configure() is called
+            model: '',
+            timeout: 120000, // 2 minutes default
+            ...config,
+        };
+    }
+    /**
+     * Called after construction to set the provider type
+     * Subclasses should call this in their constructor after super()
+     */
+    setProviderType() {
+        this.config.provider = this.type;
+    }
+    // Default capability checks (can be overridden)
+    supportsVision() {
+        const model = this.getSelectedModel();
+        return model?.supportsVision ?? false;
+    }
+    supportsDocuments() {
+        const model = this.getSelectedModel();
+        return model?.supportsDocuments ?? false;
+    }
+    supportsFunctionCalling() {
+        const model = this.getSelectedModel();
+        return model?.supportsFunctionCalling ?? false;
+    }
+    supportsStreaming() {
+        const model = this.getSelectedModel();
+        return model?.supportsStreaming ?? false;
+    }
+    // Configuration methods
+    configure(config) {
+        this.config = { ...this.config, ...config };
+        logger.debug(`${this.name} provider configured`, {
+            model: config.model,
+            hasApiKey: !!config.apiKey,
+        });
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    isConfigured() {
+        return !!this.config.apiKey && !!this.config.model;
+    }
+    // Helper methods
+    getSelectedModel() {
+        return this.supportedModels.find(m => m.id === this.config.model);
+    }
+    validateMessages(messages) {
+        if (!messages || messages.length === 0) {
+            throw new Error('Messages array cannot be empty');
+        }
+        for (const msg of messages) {
+            if (!['user', 'assistant', 'system'].includes(msg.role)) {
+                throw new Error(`Invalid message role: ${msg.role}`);
+            }
+        }
+    }
+    buildSystemPrompt(options) {
+        return options?.systemPrompt;
+    }
+    // Default streaming implementation (providers can override)
+    async *chatStream(messages, options) {
+        // Default non-streaming implementation
+        try {
+            const response = await this.chat(messages, options);
+            yield {
+                type: 'text',
+                content: response.content,
+            };
+            yield {
+                type: 'done',
+                usage: response.usage,
+            };
+        }
+        catch (error) {
+            yield {
+                type: 'error',
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    // Default image analysis (providers can override)
+    async analyzeImage(image, prompt) {
+        if (!this.supportsVision()) {
+            throw new Error(`${this.name} provider does not support image analysis`);
+        }
+        const analysisPrompt = prompt || 'Analyze this image and describe what you see, including any UI components, layout structure, colors, and design patterns.';
+        const messages = [
+            {
+                role: 'user',
+                content: [
+                    { type: 'text', text: analysisPrompt },
+                    image,
+                ],
+            },
+        ];
+        const response = await this.chat(messages);
+        // Parse the response to extract structured information
+        return {
+            description: response.content,
+            // Additional parsing could be done here based on the prompt
+        };
+    }
+    // Simple token estimation (providers can override with more accurate methods)
+    estimateTokens(text) {
+        // Rough estimate: ~4 characters per token for English text
+        return Math.ceil(text.length / 4);
+    }
+    // Request logging
+    logRequest(messages, options) {
+        logger.debug(`${this.name} API request`, {
+            model: options?.model || this.config.model,
+            messageCount: messages.length,
+            hasSystemPrompt: !!options?.systemPrompt,
+        });
+    }
+    logResponse(response) {
+        logger.debug(`${this.name} API response`, {
+            model: response.model,
+            finishReason: response.finishReason,
+            usage: response.usage,
+        });
+    }
+}

package/dist/story-generator/llm-providers/claude-provider.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Claude LLM Provider
+ *
+ * Implementation of the LLM provider interface for Anthropic's Claude models.
+ */
+import { ProviderType, ProviderConfig, ModelInfo, ChatMessage, ChatOptions, ChatResponse, StreamChunk, ValidationResult } from './types.js';
+import { BaseLLMProvider } from './base-provider.js';
+export declare class ClaudeProvider extends BaseLLMProvider {
+    readonly name = "Claude";
+    readonly type: ProviderType;
+    readonly supportedModels: ModelInfo[];
+    constructor(config?: Partial<ProviderConfig>);
+    chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse>;
+    chatStream(messages: ChatMessage[], options?: ChatOptions): AsyncIterable<StreamChunk>;
+    validateApiKey(apiKey: string): Promise<ValidationResult>;
+    private convertMessages;
+    private convertContent;
+    private convertResponse;
+    private mapStopReason;
+    estimateTokens(text: string): number;
+}
+export declare function createClaudeProvider(config?: Partial<ProviderConfig>): ClaudeProvider;
+//# sourceMappingURL=claude-provider.d.ts.map

package/dist/story-generator/llm-providers/claude-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-provider.d.ts","sourceRoot":"","sources":["../../../story-generator/llm-providers/claude-provider.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,YAAY,EACZ,cAAc,EACd,SAAS,EACT,WAAW,EACX,WAAW,EACX,YAAY,EACZ,WAAW,EACX,gBAAgB,EAGjB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAwJrD,qBAAa,cAAe,SAAQ,eAAe;IACjD,QAAQ,CAAC,IAAI,YAAY;IACzB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAY;IACvC,QAAQ,CAAC,eAAe,cAAiB;gBAE7B,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC;IAUtC,IAAI,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAkE1E,UAAU,CACf,QAAQ,EAAE,WAAW,EAAE,EACvB,OAAO,CAAC,EAAE,WAAW,GACpB,aAAa,CAAC,WAAW,CAAC;IAuGvB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAgD/D,OAAO,CAAC,eAAe;IASvB,OAAO,CAAC,cAAc;IAgCtB,OAAO,CAAC,eAAe;IAoBvB,OAAO,CAAC,aAAa;IAiBrB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAMrC;AAGD,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,cAAc,CAErF"}