@nice2dev/ui-tools 1.0.10

package/dist/ai-playgrounds.d.ts

@@ -0,0 +1,842 @@
+/**
+ * @file ai-playgrounds.ts
+ * @module @nice2dev/ui-tools
+ * @description PRO-18.5 — AI Playgrounds
+ *
+ * Types for AI playgrounds: LLM chat, prompt engineering, embeddings visualizer,
+ * image generation, text-to-speech, speech-to-text, translation, NER, QA, code generation.
+ */
+/** AI task type */
+export type AITaskType = 'chat' | 'completion' | 'embedding' | 'imageGeneration' | 'imageEdit' | 'tts' | 'stt' | 'translation' | 'sentiment' | 'ner' | 'qa' | 'summarization' | 'codeGeneration' | 'classification' | 'custom';
+/** LLM provider */
+export type LLMProvider = 'openai' | 'anthropic' | 'google' | 'cohere' | 'mistral' | 'meta' | 'huggingface' | 'azure' | 'aws_bedrock' | 'local' | 'custom';
+/** Image generation provider */
+export type ImageGenProvider = 'openai_dalle' | 'stability' | 'midjourney' | 'replicate' | 'huggingface' | 'local' | 'custom';
+/** AI playground config */
+export interface AIPlaygroundConfig {
+    /** Theme */
+    theme?: PlaygroundTheme;
+    /** Features */
+    features?: PlaygroundFeatures;
+    /** Providers */
+    providers?: ProviderConfig[];
+    /** Prompt templates */
+    promptTemplates?: PromptTemplateLibrary;
+    /** Usage tracking */
+    usage?: UsageTrackingConfig;
+}
+/** Playground theme */
+export interface PlaygroundTheme {
+    name?: string;
+    colors?: PlaygroundColors;
+    codeTheme?: string;
+}
+/** Playground colors */
+export interface PlaygroundColors {
+    primary?: string;
+    userMessage?: string;
+    assistantMessage?: string;
+    systemMessage?: string;
+    codeBackground?: string;
+}
+/** Playground features */
+export interface PlaygroundFeatures {
+    chat?: boolean;
+    promptEngineering?: boolean;
+    embeddings?: boolean;
+    imageGeneration?: boolean;
+    tts?: boolean;
+    stt?: boolean;
+    translation?: boolean;
+    sentiment?: boolean;
+    ner?: boolean;
+    qa?: boolean;
+    codeGeneration?: boolean;
+    comparison?: boolean;
+    history?: boolean;
+}
+/** Provider config */
+export interface ProviderConfig {
+    provider: LLMProvider | ImageGenProvider;
+    apiKey?: string;
+    baseUrl?: string;
+    models?: string[];
+    defaultModel?: string;
+    maxTokens?: number;
+}
+/** Usage tracking config */
+export interface UsageTrackingConfig {
+    enabled?: boolean;
+    budgetLimit?: number;
+    alertThreshold?: number;
+    trackByUser?: boolean;
+}
+/** LLM playground session */
+export interface LLMPlaygroundSession {
+    id: string;
+    name?: string;
+    provider: LLMProvider;
+    model: string;
+    messages: PlaygroundMessage[];
+    config: LLMConfig;
+    usage?: LLMUsage;
+    metadata?: SessionMetadata;
+    createdAt: Date;
+    updatedAt?: Date;
+}
+/** Playground message */
+export interface PlaygroundMessage {
+    id: string;
+    role: MessageRole;
+    content: string | MessageContent[];
+    name?: string;
+    functionCall?: FunctionCall;
+    toolCalls?: ToolCall[];
+    timestamp: Date;
+    tokens?: number;
+    latency?: number;
+    model?: string;
+}
+/** Message role */
+export type MessageRole = 'system' | 'user' | 'assistant' | 'function' | 'tool';
+/** Message content */
+export interface MessageContent {
+    type: 'text' | 'image_url' | 'audio';
+    text?: string;
+    imageUrl?: string;
+    audioUrl?: string;
+}
+/** Function call */
+export interface FunctionCall {
+    name: string;
+    arguments: string;
+}
+/** Tool call */
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: FunctionCall;
+}
+/** LLM config */
+export interface LLMConfig {
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    maxTokens?: number;
+    stopSequences?: string[];
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    seed?: number;
+    responseFormat?: ResponseFormat;
+    tools?: Tool[];
+    toolChoice?: ToolChoice;
+}
+/** Response format */
+export interface ResponseFormat {
+    type: 'text' | 'json_object' | 'json_schema';
+    schema?: Record<string, unknown>;
+}
+/** Tool */
+export interface Tool {
+    type: 'function';
+    function: FunctionDefinition;
+}
+/** Function definition */
+export interface FunctionDefinition {
+    name: string;
+    description?: string;
+    parameters?: JSONSchema;
+}
+/** JSON schema */
+export interface JSONSchema {
+    type: string;
+    properties?: Record<string, JSONSchema>;
+    required?: string[];
+    items?: JSONSchema;
+    enum?: unknown[];
+    description?: string;
+    [key: string]: unknown;
+}
+/** Tool choice */
+export type ToolChoice = 'auto' | 'none' | 'required' | {
+    type: 'function';
+    function: {
+        name: string;
+    };
+};
+/** LLM usage */
+export interface LLMUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    cost?: number;
+}
+/** Session metadata */
+export interface SessionMetadata {
+    createdBy?: string;
+    tags?: string[];
+    labels?: Record<string, string>;
+    notes?: string;
+}
+/** Prompt template library */
+export interface PromptTemplateLibrary {
+    templates: PromptTemplate[];
+    categories?: PromptCategory[];
+    versions?: PromptVersionControl;
+}
+/** Prompt template */
+export interface PromptTemplate {
+    id: string;
+    name: string;
+    description?: string;
+    category?: string;
+    template: string;
+    variables?: PromptVariable[];
+    examples?: PromptExample[];
+    metadata?: PromptMetadata;
+    version?: string;
+    createdAt: Date;
+    updatedAt?: Date;
+}
+/** Prompt variable */
+export interface PromptVariable {
+    name: string;
+    description?: string;
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+    required?: boolean;
+    default?: unknown;
+    validation?: VariableValidation;
+}
+/** Variable validation */
+export interface VariableValidation {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    enum?: unknown[];
+}
+/** Prompt example */
+export interface PromptExample {
+    variables: Record<string, unknown>;
+    expectedOutput?: string;
+    tags?: string[];
+}
+/** Prompt category */
+export interface PromptCategory {
+    id: string;
+    name: string;
+    description?: string;
+    icon?: string;
+    parent?: string;
+}
+/** Prompt metadata */
+export interface PromptMetadata {
+    author?: string;
+    tags?: string[];
+    model?: string;
+    useCase?: string;
+    performance?: PromptPerformance;
+}
+/** Prompt performance */
+export interface PromptPerformance {
+    averageLatency?: number;
+    averageTokens?: number;
+    successRate?: number;
+    userRating?: number;
+}
+/** Prompt version control */
+export interface PromptVersionControl {
+    enabled: boolean;
+    history: PromptVersion[];
+}
+/** Prompt version */
+export interface PromptVersion {
+    version: string;
+    template: string;
+    changes?: string;
+    author?: string;
+    timestamp: Date;
+}
+/** Prompt test */
+export interface PromptTest {
+    id: string;
+    templateId: string;
+    cases: PromptTestCase[];
+    results?: PromptTestResult[];
+    summary?: PromptTestSummary;
+}
+/** Prompt test case */
+export interface PromptTestCase {
+    id: string;
+    name?: string;
+    variables: Record<string, unknown>;
+    assertions?: PromptAssertion[];
+    expectedOutput?: string;
+}
+/** Prompt assertion */
+export interface PromptAssertion {
+    type: 'contains' | 'not_contains' | 'matches' | 'json_schema' | 'sentiment' | 'custom';
+    value: unknown;
+}
+/** Prompt test result */
+export interface PromptTestResult {
+    caseId: string;
+    passed: boolean;
+    output: string;
+    assertions: AssertionResult[];
+    latency: number;
+    tokens: number;
+}
+/** Assertion result */
+export interface AssertionResult {
+    assertion: PromptAssertion;
+    passed: boolean;
+    actual?: unknown;
+    message?: string;
+}
+/** Prompt test summary */
+export interface PromptTestSummary {
+    total: number;
+    passed: number;
+    failed: number;
+    averageLatency: number;
+    averageTokens: number;
+}
+/** Embedding visualizer config */
+export interface EmbeddingVisualizerConfig {
+    model: string;
+    provider: LLMProvider;
+    reduction: DimensionReduction;
+    clustering?: ClusteringConfig;
+    display?: EmbeddingDisplayConfig;
+}
+/** Dimension reduction */
+export interface DimensionReduction {
+    method: 'tsne' | 'umap' | 'pca';
+    dimensions: 2 | 3;
+    params?: ReductionParams;
+}
+/** Reduction params */
+export interface ReductionParams {
+    perplexity?: number;
+    iterations?: number;
+    learningRate?: number;
+    nNeighbors?: number;
+    minDist?: number;
+    metric?: string;
+    nComponents?: number;
+}
+/** Clustering config */
+export interface ClusteringConfig {
+    enabled: boolean;
+    method: 'kmeans' | 'dbscan' | 'hdbscan' | 'agglomerative';
+    params?: ClusteringParams;
+}
+/** Clustering params */
+export interface ClusteringParams {
+    nClusters?: number;
+    eps?: number;
+    minSamples?: number;
+    linkage?: string;
+}
+/** Embedding display config */
+export interface EmbeddingDisplayConfig {
+    pointSize?: number;
+    colorBy?: 'cluster' | 'label' | 'custom';
+    showLabels?: boolean;
+    interactive?: boolean;
+}
+/** Embedding data */
+export interface EmbeddingData {
+    points: EmbeddingPoint[];
+    metadata?: EmbeddingMetadata;
+    clusters?: ClusterInfo[];
+}
+/** Embedding point */
+export interface EmbeddingPoint {
+    id: string;
+    text: string;
+    vector?: number[];
+    coordinates: number[];
+    label?: string;
+    cluster?: number;
+    metadata?: Record<string, unknown>;
+}
+/** Embedding metadata */
+export interface EmbeddingMetadata {
+    model: string;
+    dimensions: number;
+    pointCount: number;
+    reductionMethod: string;
+}
+/** Cluster info */
+export interface ClusterInfo {
+    id: number;
+    size: number;
+    centroid: number[];
+    label?: string;
+    keywords?: string[];
+}
+/** Image generation request */
+export interface ImageGenerationRequest {
+    prompt: string;
+    negativePrompt?: string;
+    model: string;
+    provider: ImageGenProvider;
+    config: ImageGenConfig;
+}
+/** Image gen config */
+export interface ImageGenConfig {
+    width?: number;
+    height?: number;
+    numImages?: number;
+    steps?: number;
+    guidanceScale?: number;
+    seed?: number;
+    style?: string;
+    quality?: 'standard' | 'hd';
+    responseFormat?: 'url' | 'b64_json';
+    sampler?: string;
+}
+/** Image generation result */
+export interface ImageGenerationResult {
+    id: string;
+    images: GeneratedImage[];
+    prompt: string;
+    model: string;
+    config: ImageGenConfig;
+    timestamp: Date;
+    cost?: number;
+}
+/** Generated image */
+export interface GeneratedImage {
+    id: string;
+    url?: string;
+    base64?: string;
+    revisedPrompt?: string;
+    seed?: number;
+}
+/** Image edit request */
+export interface ImageEditRequest {
+    image: string;
+    mask?: string;
+    prompt: string;
+    model: string;
+    config: ImageGenConfig;
+}
+/** Image variation request */
+export interface ImageVariationRequest {
+    image: string;
+    model: string;
+    numVariations: number;
+    config: ImageGenConfig;
+}
+/** TTS request */
+export interface TTSRequest {
+    text: string;
+    voice: string;
+    model: string;
+    config?: TTSConfig;
+}
+/** TTS config */
+export interface TTSConfig {
+    speed?: number;
+    pitch?: number;
+    volume?: number;
+    format?: 'mp3' | 'wav' | 'ogg' | 'flac';
+    sampleRate?: number;
+}
+/** TTS result */
+export interface TTSResult {
+    id: string;
+    audioUrl?: string;
+    audioBase64?: string;
+    duration: number;
+    format: string;
+    model: string;
+    voice: string;
+}
+/** Voice option */
+export interface VoiceOption {
+    id: string;
+    name: string;
+    language: string;
+    gender?: 'male' | 'female' | 'neutral';
+    style?: string;
+    preview?: string;
+}
+/** STT request */
+export interface STTRequest {
+    audio: string | Blob;
+    model: string;
+    config?: STTConfig;
+}
+/** STT config */
+export interface STTConfig {
+    language?: string;
+    prompt?: string;
+    temperature?: number;
+    timestamps?: boolean;
+    wordTimestamps?: boolean;
+    diarization?: boolean;
+}
+/** STT result */
+export interface STTResult {
+    id: string;
+    text: string;
+    segments?: STTSegment[];
+    words?: STTWord[];
+    speakers?: STTSpeaker[];
+    language?: string;
+    duration?: number;
+    confidence?: number;
+}
+/** STT segment */
+export interface STTSegment {
+    id: number;
+    start: number;
+    end: number;
+    text: string;
+    confidence?: number;
+    speaker?: string;
+}
+/** STT word */
+export interface STTWord {
+    word: string;
+    start: number;
+    end: number;
+    confidence?: number;
+}
+/** STT speaker */
+export interface STTSpeaker {
+    id: string;
+    label?: string;
+    segments: number[];
+}
+/** Translation request */
+export interface TranslationRequest {
+    text: string;
+    sourceLang?: string;
+    targetLang: string;
+    model?: string;
+    formality?: 'formal' | 'informal';
+}
+/** Translation result */
+export interface TranslationResult {
+    id: string;
+    originalText: string;
+    translatedText: string;
+    sourceLang: string;
+    targetLang: string;
+    alternatives?: string[];
+    confidence?: number;
+}
+/** Language option */
+export interface LanguageOption {
+    code: string;
+    name: string;
+    nativeName?: string;
+    supported?: boolean;
+}
+/** Sentiment request */
+export interface SentimentRequest {
+    text: string;
+    model?: string;
+    aspects?: string[];
+    granularity?: 'document' | 'sentence' | 'aspect';
+}
+/** Sentiment result */
+export interface SentimentResult {
+    id: string;
+    text: string;
+    overall: SentimentScore;
+    sentences?: SentenceSentiment[];
+    aspects?: AspectSentiment[];
+    emotions?: EmotionScore[];
+}
+/** Sentiment score */
+export interface SentimentScore {
+    label: 'positive' | 'negative' | 'neutral' | 'mixed';
+    score: number;
+    confidence: number;
+}
+/** Sentence sentiment */
+export interface SentenceSentiment {
+    text: string;
+    start: number;
+    end: number;
+    sentiment: SentimentScore;
+}
+/** Aspect sentiment */
+export interface AspectSentiment {
+    aspect: string;
+    sentiment: SentimentScore;
+    mentions: AspectMention[];
+}
+/** Aspect mention */
+export interface AspectMention {
+    text: string;
+    start: number;
+    end: number;
+}
+/** Emotion score */
+export interface EmotionScore {
+    emotion: string;
+    score: number;
+}
+/** NER request */
+export interface NERRequest {
+    text: string;
+    model?: string;
+    entityTypes?: string[];
+}
+/** NER result */
+export interface NERResult {
+    id: string;
+    text: string;
+    entities: NamedEntity[];
+    entityCounts: Record<string, number>;
+}
+/** Named entity */
+export interface NamedEntity {
+    text: string;
+    type: string;
+    start: number;
+    end: number;
+    confidence?: number;
+    normalized?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Entity type definition */
+export interface EntityTypeDefinition {
+    type: string;
+    label: string;
+    color?: string;
+    description?: string;
+}
+/** QA request */
+export interface QARequest {
+    question: string;
+    context?: string;
+    documents?: QADocument[];
+    model?: string;
+    config?: QAConfig;
+}
+/** QA document */
+export interface QADocument {
+    id: string;
+    text: string;
+    metadata?: Record<string, unknown>;
+}
+/** QA config */
+export interface QAConfig {
+    maxAnswerLength?: number;
+    numAnswers?: number;
+    minConfidence?: number;
+    useRetrieval?: boolean;
+}
+/** QA result */
+export interface QAResult {
+    id: string;
+    question: string;
+    answers: QAAnswer[];
+    retrievedDocuments?: RetrievedDocument[];
+}
+/** QA answer */
+export interface QAAnswer {
+    text: string;
+    confidence: number;
+    start?: number;
+    end?: number;
+    documentId?: string;
+    context?: string;
+}
+/** Retrieved document */
+export interface RetrievedDocument {
+    id: string;
+    text: string;
+    score: number;
+    metadata?: Record<string, unknown>;
+}
+/** Code generation request */
+export interface CodeGenerationRequest {
+    prompt: string;
+    language: string;
+    model?: string;
+    config?: CodeGenConfig;
+    context?: CodeContext;
+}
+/** Code gen config */
+export interface CodeGenConfig {
+    maxTokens?: number;
+    temperature?: number;
+    stopSequences?: string[];
+    includeExplanation?: boolean;
+    includeTests?: boolean;
+}
+/** Code context */
+export interface CodeContext {
+    files?: CodeFile[];
+    dependencies?: string[];
+    framework?: string;
+    style?: string;
+}
+/** Code file */
+export interface CodeFile {
+    path: string;
+    content: string;
+    language?: string;
+}
+/** Code generation result */
+export interface CodeGenerationResult {
+    id: string;
+    code: string;
+    language: string;
+    explanation?: string;
+    tests?: string;
+    suggestions?: CodeSuggestion[];
+}
+/** Code suggestion */
+export interface CodeSuggestion {
+    type: 'completion' | 'refactor' | 'fix' | 'optimization';
+    code: string;
+    description?: string;
+    confidence?: number;
+}
+/** Code completion request */
+export interface CodeCompletionRequest {
+    prefix: string;
+    suffix?: string;
+    language: string;
+    model?: string;
+    maxCompletions?: number;
+}
+/** Code completion result */
+export interface CodeCompletionResult {
+    completions: CodeCompletion[];
+}
+/** Code completion */
+export interface CodeCompletion {
+    text: string;
+    confidence?: number;
+    range?: CompletionRange;
+}
+/** Completion range */
+export interface CompletionRange {
+    start: number;
+    end: number;
+}
+/** Model comparison session */
+export interface ModelComparisonSession {
+    id: string;
+    name?: string;
+    models: ComparisonModel[];
+    prompts: ComparisonPrompt[];
+    results: ComparisonResult[];
+    summary?: ComparisonSummary;
+    createdAt: Date;
+}
+/** Comparison model */
+export interface ComparisonModel {
+    id: string;
+    provider: LLMProvider;
+    model: string;
+    config?: LLMConfig;
+}
+/** Comparison prompt */
+export interface ComparisonPrompt {
+    id: string;
+    messages: PlaygroundMessage[];
+    tags?: string[];
+}
+/** Comparison result */
+export interface ComparisonResult {
+    promptId: string;
+    modelId: string;
+    response: string;
+    latency: number;
+    tokens: number;
+    cost?: number;
+    rating?: number;
+}
+/** Comparison summary */
+export interface ComparisonSummary {
+    winner?: string;
+    metrics: ComparisonMetrics[];
+    analysis?: string;
+}
+/** Comparison metrics */
+export interface ComparisonMetrics {
+    modelId: string;
+    averageLatency: number;
+    totalTokens: number;
+    totalCost?: number;
+    averageRating?: number;
+}
+/** Usage stats */
+export interface AIUsageStats {
+    period: string;
+    requests: number;
+    tokens: UsageTokens;
+    cost: number;
+    byModel: ModelUsage[];
+    byTask: TaskUsage[];
+    timeline?: UsageTimeline;
+}
+/** Usage tokens */
+export interface UsageTokens {
+    prompt: number;
+    completion: number;
+    total: number;
+}
+/** Model usage */
+export interface ModelUsage {
+    model: string;
+    provider: string;
+    requests: number;
+    tokens: number;
+    cost: number;
+}
+/** Task usage */
+export interface TaskUsage {
+    task: AITaskType;
+    requests: number;
+    tokens: number;
+    cost: number;
+}
+/** Usage timeline */
+export interface UsageTimeline {
+    timestamps: Date[];
+    requests: number[];
+    tokens: number[];
+    cost: number[];
+}
+/** Playground history */
+export interface PlaygroundHistory {
+    sessions: HistorySession[];
+    totalCount: number;
+    filters?: HistoryFilters;
+}
+/** History session */
+export interface HistorySession {
+    id: string;
+    type: AITaskType;
+    model: string;
+    preview: string;
+    tokens?: number;
+    cost?: number;
+    createdAt: Date;
+    tags?: string[];
+}
+/** History filters */
+export interface HistoryFilters {
+    dateRange?: DateRange;
+    models?: string[];
+    tasks?: AITaskType[];
+    tags?: string[];
+}
+/** Date range */
+export interface DateRange {
+    start: Date;
+    end: Date;
+}
+//# sourceMappingURL=ai-playgrounds.d.ts.map