@phantasy/sheesh-agent/dist/index.d.ts

AI Agent Framework with multi-provider support and real-time broadcasting

/**
 * Core types for the AI Framework
 */
interface ProviderConfig {
    provider?: string;
    apiKey?: string;
    baseUrl?: string;
    timeout?: number;
    maxRetries?: number;
    privyToken?: string;
    [key: string]: any;
}
interface UsageStats {
    tokensUsed?: number;
    requestsCount?: number;
    cost?: number;
    remaining?: number;
}
type ProviderType = 'text' | 'tts' | 'image' | 'embedding';
interface AIProvider {
    id: string;
    name: string;
    type: ProviderType;
    initialize(config: ProviderConfig): Promise<void>;
    isAvailable(): Promise<boolean>;
    getUsage(): Promise<UsageStats>;
}
interface TextGenerationOptions {
    model?: string;
    temperature?: number;
    maxTokens?: number;
    topP?: number;
    frequencyPenalty?: number;
    presencePenalty?: number;
    systemPrompt?: string;
    stop?: string[];
    stream?: boolean;
}
interface TextResponse {
    text: string;
    model: string;
    usage?: {
        promptTokens: number;
        completionTokens: number;
        totalTokens: number;
    };
    finishReason?: string;
}
interface TTSOptions {
    voice?: string;
    model?: string;
    speed?: number;
    pitch?: number;
    volume?: number;
    emotion?: string;
    format?: AudioFormat;
    sampleRate?: number;
}
type AudioFormat = 'mp3' | 'wav' | 'ogg' | 'aac' | 'flac' | 'opus';
interface Voice {
    id: string;
    name: string;
    gender?: 'male' | 'female' | 'neutral';
    language?: string;
    previewUrl?: string;
    labels?: Record<string, string>;
}
interface AudioResponse {
    audio: ArrayBuffer;
    format: AudioFormat;
    duration?: number;
    voice?: string;
}
interface ImageGenerationOptions {
    model?: string;
    size?: string;
    quality?: 'standard' | 'hd';
    style?: string;
    n?: number;
}
interface ImageResponse {
    images: Array<{
        url?: string;
        base64?: string;
        revisedPrompt?: string;
    }>;
    model: string;
}
interface Message {
    role: 'system' | 'user' | 'assistant';
    content: string;
    timestamp?: Date;
    metadata?: Record<string, any>;
}
interface ConversationContext {
    conversationId: string;
    userId: string;
    agentId?: string;
    messages: Message[];
    metadata?: Record<string, any>;
}
interface PersonalityProfile {
    name: string;
    description: string;
    traits: string[];
    tone: 'friendly' | 'professional' | 'casual' | 'humorous' | 'serious';
    guidelines: string[];
    examples?: Array<{
        input: string;
        output: string;
    }>;
}
interface AIResponse {
    text: string;
    audio?: ArrayBuffer;
    audioUrl?: string;
    emotion?: string;
    actions?: AgentAction[];
    metadata?: Record<string, any>;
}
interface AgentAction {
    type: 'animation' | 'expression' | 'sound' | 'custom' | 'vrm' | 'camera' | 'canvas' | 'tip' | 'audio';
    value: string | number | {
        x: number;
        y: number;
        z: number;
    };
    duration?: number;
    delay?: number;
    action?: string;
    intensity?: number;
    blendMode?: string;
    easing?: string;
    position?: {
        x: number;
        y: number;
    };
    size?: {
        width: number;
        height: number;
    };
    amount?: number;
    currency?: string;
    animation?: string;
    volume?: number;
    fadeIn?: number;
    fadeOut?: number;
}
declare class AIFrameworkError extends Error {
    code: string;
    provider?: string | undefined;
    details?: any | undefined;
    constructor(message: string, code: string, provider?: string | undefined, details?: any | undefined);
}
declare class ProviderError extends AIFrameworkError {
    constructor(message: string, provider: string, details?: any);
}
declare class ConfigurationError extends AIFrameworkError {
    constructor(message: string, details?: any);
}
declare class RateLimitError extends AIFrameworkError {
    constructor(message: string, provider: string, retryAfter?: number);
}

/**
 * Base provider class that all AI providers extend
 */

declare abstract class BaseProvider implements AIProvider {
    readonly id: string;
    readonly name: string;
    readonly type: ProviderType;
    protected config: ProviderConfig;
    protected initialized: boolean;
    constructor(id: string, name: string, type: ProviderType);
    initialize(config: ProviderConfig): Promise<void>;
    isAvailable(): Promise<boolean>;
    getUsage(): Promise<UsageStats>;
    protected abstract onInitialize(): Promise<void>;
    protected abstract checkAvailability(): Promise<boolean>;
    protected abstract fetchUsage(): Promise<UsageStats>;
    protected ensureInitialized(): void;
}

/**
 * OpenAI text generation provider
 */

interface OpenAITextProvider extends BaseProvider {
    generate(prompt: string, options?: TextGenerationOptions): Promise<TextResponse>;
    generateWithMessages(messages: Message[], options?: TextGenerationOptions): Promise<TextResponse>;
    stream(prompt: string, options?: TextGenerationOptions): AsyncGenerator<string>;
}
declare class OpenAIText extends BaseProvider implements OpenAITextProvider {
    private client?;
    constructor();
    protected onInitialize(): Promise<void>;
    protected checkAvailability(): Promise<boolean>;
    protected fetchUsage(): Promise<UsageStats>;
    generate(prompt: string, options?: TextGenerationOptions): Promise<TextResponse>;
    generateWithMessages(messages: Message[], options?: TextGenerationOptions): Promise<TextResponse>;
    stream(prompt: string, options?: TextGenerationOptions): AsyncGenerator<string>;
}

/**
 * OpenAI Text-to-Speech provider
 */

interface OpenAITTSProvider extends BaseProvider {
    synthesize(text: string, options?: TTSOptions): Promise<AudioResponse>;
    getVoices(): Promise<Voice[]>;
    stream(text: string, options?: TTSOptions): Promise<ReadableStream<Uint8Array>>;
}
declare class OpenAITTS extends BaseProvider implements OpenAITTSProvider {
    private client?;
    private static readonly VOICES;
    constructor();
    protected onInitialize(): Promise<void>;
    protected checkAvailability(): Promise<boolean>;
    protected fetchUsage(): Promise<UsageStats>;
    synthesize(text: string, options?: TTSOptions): Promise<AudioResponse>;
    getVoices(): Promise<Voice[]>;
    stream(text: string, options?: TTSOptions): Promise<ReadableStream<Uint8Array>>;
    private mapAudioFormat;
}

/**
 * Conversation management service
 */

interface ConversationOptions {
    enableTTS?: boolean;
    enableActions?: boolean;
    maxContextMessages?: number;
    temperature?: number;
}
declare class ConversationService {
    private textProvider;
    private ttsProvider?;
    private options;
    private conversations;
    constructor(textProvider: OpenAITextProvider, ttsProvider?: OpenAITTSProvider | undefined, options?: ConversationOptions);
    processMessage(userId: string, message: string, personality?: PersonalityProfile, metadata?: Record<string, any>): Promise<AIResponse>;
    private prepareMessages;
    private buildPersonalityPrompt;
    private trimContext;
    private extractActions;
    private detectEmotion;
    clearConversation(conversationId: string): void;
    getConversation(conversationId: string): ConversationContext | undefined;
}

/**
 * Enhanced Agent Controller for VRM characters
 * Provides comprehensive control over AI agents including VRM models, camera, tips, and interactions
 */

interface VRMControlAction {
    type: 'vrm';
    action: 'animation' | 'expression' | 'pose' | 'gesture' | 'movement';
    value: string;
    duration?: number;
    intensity?: number;
    blendMode?: 'replace' | 'additive' | 'override';
}
interface CameraControlAction {
    type: 'camera';
    action: 'position' | 'rotation' | 'zoom' | 'focus' | 'preset';
    value: string | number | {
        x: number;
        y: number;
        z: number;
    };
    duration?: number;
    easing?: 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out';
}
interface CanvasAction {
    type: 'canvas';
    action: 'draw' | 'clear' | 'overlay' | 'background' | 'effect';
    value: string;
    position?: {
        x: number;
        y: number;
    };
    size?: {
        width: number;
        height: number;
    };
    duration?: number;
}
interface AgentState {
    personality: PersonalityProfile;
    currentEmotion: string;
    energyLevel: number;
    tipGoals: TipGoal$1[];
    activeAnimations: string[];
    cameraPosition: {
        x: number;
        y: number;
        z: number;
    };
    lastInteraction: Date;
    conversationContext: string[];
}
interface TipGoal$1 {
    id: string;
    description: string;
    targetAmount: number;
    currentAmount: number;
    currency: 'SOL' | 'NEAR' | 'ETH';
    reward: string;
    animation?: string;
    isActive: boolean;
}
interface AgentMemory {
    userId: string;
    interactions: number;
    favoriteTopics: string[];
    tipHistory: Array<{
        amount: number;
        currency: string;
        animation: string;
        timestamp: Date;
    }>;
    preferences: Record<string, any>;
}
declare class AgentController {
    private conversationService;
    private state;
    private memory;
    private actionQueue;
    constructor(conversationService: ConversationService, initialPersonality: PersonalityProfile);
    processUserMessage(userId: string, message: string, metadata?: Record<string, any>): Promise<AIResponse & {
        actions: AgentAction[];
    }>;
    private analyzeAndGenerateActions;
    private updateUserMemory;
    private updateAgentState;
    private extractTopics;
    getUserMemory(userId: string): AgentMemory | undefined;
    getPublicState(): Omit<AgentState, 'conversationContext'>;
    addTipGoal(goal: Omit<TipGoal$1, 'id' | 'currentAmount' | 'isActive'>): string;
    updateTipGoal(goalId: string, amount: number): boolean;
    getActiveTipGoals(): TipGoal$1[];
    queueAction(action: AgentAction): void;
    getNextAction(): AgentAction | undefined;
    updatePersonality(updates: Partial<PersonalityProfile>): void;
    setEmotion(emotion: string): void;
    getCameraPosition(): {
        x: number;
        y: number;
        z: number;
    };
    setCameraPosition(position: {
        x: number;
        y: number;
        z: number;
    }): void;
}

/**
 * Provider Manager with fallback support
 * Automatically tries multiple providers if one fails
 */

interface ProviderFallbackConfig {
    primary: string;
    fallbacks: string[];
    configs: Record<string, ProviderConfig>;
}
declare class ProviderManager {
    private config;
    private providers;
    private fallbackOrder;
    constructor(config: ProviderFallbackConfig);
    initialize(): Promise<void>;
    generate(prompt: string, options?: any): Promise<any>;
    generateWithMessages(messages: any[], options?: any): Promise<any>;
    getAvailableProviders(): string[];
    getProvider(name: string): AIProvider | undefined;
}

/**
 * Alkahest text generation provider (OpenAI-compatible)
 */

interface AlkahestTextProvider extends BaseProvider {
    generate(prompt: string, options?: TextGenerationOptions): Promise<TextResponse>;
    generateWithMessages(messages: Message[], options?: TextGenerationOptions): Promise<TextResponse>;
    stream(prompt: string, options?: TextGenerationOptions): AsyncGenerator<string>;
    streamWithMessages(messages: Message[], options?: TextGenerationOptions): AsyncGenerator<string>;
}
declare class AlkahestText extends BaseProvider implements AlkahestTextProvider {
    private baseUrl;
    private apiKey?;
    constructor();
    protected onInitialize(): Promise<void>;
    protected checkAvailability(): Promise<boolean>;
    protected fetchUsage(): Promise<UsageStats>;
    private getHeaders;
    generate(prompt: string, options?: TextGenerationOptions): Promise<TextResponse>;
    generateWithMessages(messages: Message[], options?: TextGenerationOptions): Promise<TextResponse>;
    stream(prompt: string, options?: TextGenerationOptions): AsyncGenerator<string>;
    streamWithMessages(messages: Message[], options?: TextGenerationOptions): AsyncGenerator<string>;
}

/**
 * Maho.sh OpenAI-compatible text generation provider
 * https://maho.sh/api/v1/chat/completions
 */

interface MahoTextProvider extends BaseProvider {
    generate(prompt: string, options?: TextGenerationOptions): Promise<TextResponse>;
    generateWithMessages(messages: Message[], options?: TextGenerationOptions): Promise<TextResponse>;
    stream(prompt: string, options?: TextGenerationOptions): AsyncGenerator<string>;
}
declare class MahoText extends BaseProvider implements MahoTextProvider {
    private client?;
    constructor();
    protected onInitialize(): Promise<void>;
    protected checkAvailability(): Promise<boolean>;
    protected fetchUsage(): Promise<UsageStats>;
    generate(prompt: string, options?: TextGenerationOptions): Promise<TextResponse>;
    generateWithMessages(messages: Message[], options?: TextGenerationOptions): Promise<TextResponse>;
    stream(prompt: string, options?: TextGenerationOptions): AsyncGenerator<string>;
}

/**
 * Akash OpenAI-compatible text generation provider
 * https://chatapi.akash.network/api/v1/chat/completions
 */

interface AkashTextProvider extends BaseProvider {
    generate(prompt: string, options?: TextGenerationOptions): Promise<TextResponse>;
    generateWithMessages(messages: Message[], options?: TextGenerationOptions): Promise<TextResponse>;
    stream(prompt: string, options?: TextGenerationOptions): AsyncGenerator<string>;
}
declare class AkashText extends BaseProvider implements AkashTextProvider {
    private client?;
    constructor();
    protected onInitialize(): Promise<void>;
    protected checkAvailability(): Promise<boolean>;
    protected fetchUsage(): Promise<UsageStats>;
    generate(prompt: string, options?: TextGenerationOptions): Promise<TextResponse>;
    generateWithMessages(messages: Message[], options?: TextGenerationOptions): Promise<TextResponse>;
    stream(prompt: string, options?: TextGenerationOptions): AsyncGenerator<string>;
}

/**
 * Alkahest Text-to-Speech provider (OpenAI-compatible)
 */

interface AlkahestTTSProvider extends BaseProvider {
    synthesize(text: string, options?: TTSOptions): Promise<AudioResponse>;
    getVoices(): Promise<Voice[]>;
    stream(text: string, options?: TTSOptions): Promise<ReadableStream<Uint8Array>>;
}
declare class AlkahestTTS extends BaseProvider implements AlkahestTTSProvider {
    private baseUrl;
    private apiKey?;
    private voices;
    constructor();
    protected onInitialize(): Promise<void>;
    protected checkAvailability(): Promise<boolean>;
    protected fetchUsage(): Promise<UsageStats>;
    private getHeaders;
    private fetchVoices;
    synthesize(text: string, options?: TTSOptions): Promise<AudioResponse>;
    getVoices(): Promise<Voice[]>;
    stream(text: string, options?: TTSOptions): Promise<ReadableStream<Uint8Array>>;
    private mapAudioFormat;
}

/**
 * Alkahest image generation provider (OpenAI-compatible)
 */

interface AlkahestImageProvider extends BaseProvider {
    generate(prompt: string, options?: ImageGenerationOptions): Promise<ImageResponse>;
}
declare class AlkahestImage extends BaseProvider implements AlkahestImageProvider {
    private baseUrl;
    private apiKey?;
    constructor();
    protected onInitialize(): Promise<void>;
    protected checkAvailability(): Promise<boolean>;
    protected fetchUsage(): Promise<UsageStats>;
    private getHeaders;
    generate(prompt: string, options?: ImageGenerationOptions): Promise<ImageResponse>;
}

/**
 * Tip Management Service for AI Agents
 * Handles tip goals, milestones, rewards, and payment integration
 */

interface TipGoal {
    id: string;
    title: string;
    description: string;
    targetAmount: number;
    currentAmount: number;
    currency: 'SOL' | 'NEAR' | 'ETH' | 'USD';
    reward: TipReward;
    isActive: boolean;
    createdAt: Date;
    completedAt?: Date;
    priority: 'low' | 'medium' | 'high';
    category: 'animation' | 'content' | 'interaction' | 'milestone';
}
interface TipReward {
    type: 'animation' | 'content' | 'special' | 'unlock';
    value: string;
    duration?: number;
    unlocks?: string[];
    message?: string;
}
interface TipTransaction {
    id: string;
    userId: string;
    amount: number;
    currency: string;
    goalId?: string;
    message?: string;
    timestamp: Date;
    transactionHash?: string;
    status: 'pending' | 'confirmed' | 'failed';
}
interface TipMilestone {
    amount: number;
    currency: string;
    reward: TipReward;
    message: string;
    achieved: boolean;
    achievedAt?: Date;
}
interface TipperStats {
    userId: string;
    totalTipped: number;
    favoriteCurrency: string;
    tipCount: number;
    largestTip: number;
    firstTipDate: Date;
    lastTipDate: Date;
    tier: 'bronze' | 'silver' | 'gold' | 'platinum' | 'diamond';
}
declare class TipManagementService {
    private goals;
    private transactions;
    private milestones;
    private tipperStats;
    private totalEarned;
    constructor();
    private initializeDefaultMilestones;
    createGoal(goal: Omit<TipGoal, 'id' | 'currentAmount' | 'createdAt'>): string;
    processTip(userId: string, amount: number, currency: string, goalId?: string, message?: string): {
        success: boolean;
        actions: AgentAction[];
        milestones: TipMilestone[];
        goalCompleted?: TipGoal;
    };
    private createRewardAction;
    private updateTipperStats;
    getActiveGoals(): TipGoal[];
    getCompletedGoals(): TipGoal[];
    getGoalProgress(goalId: string): {
        current: number;
        target: number;
        percentage: number;
    } | null;
    getTipperStats(userId: string): TipperStats | null;
    getTopTippers(limit?: number): TipperStats[];
    getTotalEarnings(): Record<string, number>;
    getRecentTransactions(limit?: number): TipTransaction[];
    getMilestoneProgress(): Array<TipMilestone & {
        progress: number;
    }>;
    generateTipRequestMessage(goalId?: string): string;
    updateGoal(goalId: string, updates: Partial<TipGoal>): boolean;
    deleteGoal(goalId: string): boolean;
    getUserTipHistory(userId: string): TipTransaction[];
}

/**
 * Audio Control Service for AI Agents
 * Handles TTS, background music, sound effects, and audio management
 */

interface AudioPlaybackState {
    trackId: string;
    isPlaying: boolean;
    currentTime: number;
    volume: number;
    loop: boolean;
    fadeInDuration?: number;
    fadeOutDuration?: number;
}
interface TTSRequest {
    text: string;
    voice: string;
    speed: number;
    pitch: number;
    emotion?: string;
    style?: string;
    language?: string;
}
interface SoundEffect {
    id: string;
    name: string;
    type: 'celebration' | 'notification' | 'interaction' | 'ambient' | 'transition';
    url: string;
    volume: number;
    duration: number;
    triggers: string[];
}
interface VoiceProfile {
    id: string;
    name: string;
    description: string;
    provider: 'openai' | 'alkahest' | 'elevenlabs' | 'azure';
    voiceId: string;
    language: string;
    gender: 'male' | 'female' | 'neutral';
    age: 'child' | 'young' | 'adult' | 'senior';
    characteristics: string[];
    emotionalRange: string[];
    sampleUrl?: string;
}
interface AudioScene {
    id: string;
    name: string;
    description: string;
    backgroundMusic?: string;
    ambientSounds: string[];
    volume: {
        master: number;
        music: number;
        sfx: number;
        ambient: number;
        tts: number;
    };
    mood: string;
    duration?: number;
}
declare class AudioControlService {
    private currentTracks;
    private soundEffects;
    private voiceProfiles;
    private audioScenes;
    private currentScene?;
    private masterVolume;
    private ttsQueue;
    private isProcessingTTS;
    constructor();
    private initializeDefaultSounds;
    private initializeVoiceProfiles;
    private initializeAudioScenes;
    processAudioAction(action: AgentAction): Promise<{
        success: boolean;
        data?: any;
    }>;
    generateTTS(request: TTSRequest): Promise<{
        success: boolean;
        audioUrl?: string;
        duration?: number;
    }>;
    private processTTSQueue;
    playAudio(trackId: string, options?: {
        volume?: number;
        loop?: boolean;
        fadeIn?: number;
        fadeOut?: number;
    }): {
        success: boolean;
        data?: any;
    };
    stopAudio(trackId: string): {
        success: boolean;
        data?: any;
    };
    playEffect(effectId: string): {
        success: boolean;
        data?: any;
    };
    setVolume(trackId: string, volume: number): {
        success: boolean;
        data?: any;
    };
    setMasterVolume(volume: number): void;
    getMasterVolume(): number;
    setAudioScene(sceneId: string): {
        success: boolean;
        data?: any;
    };
    private stopScene;
    getCurrentPlayingTracks(): AudioPlaybackState[];
    getAvailableVoices(): VoiceProfile[];
    getVoiceByEmotion(emotion: string): VoiceProfile | null;
    getSoundEffectsByTrigger(trigger: string): SoundEffect[];
    getAudioScenes(): AudioScene[];
    getCurrentScene(): AudioScene | null;
    createDynamicAudioResponse(emotion: string, context: string, intensity?: number): AgentAction[];
    analyzeAudioMood(currentTracks: string[]): string;
    queueTTS(text: string, voice?: string, emotion?: string): string;
    stopAllAudio(): void;
    crossfade(fromTrackId: string, toTrackId: string, duration?: number): void;
}

/**
 * VRM Integration Service
 * Provides AI agents with direct control over VRM models, animations, and expressions
 */

interface VRMAnimation {
    id: string;
    name: string;
    file: string;
    duration: number;
    category: 'idle' | 'gesture' | 'dance' | 'expression' | 'special';
    emotionalTone: 'neutral' | 'happy' | 'sad' | 'excited' | 'angry' | 'surprised';
    requiredTier: 'free' | 'premium' | 'vip';
}
interface VRMExpression {
    id: string;
    name: string;
    morphTargets: Record<string, number>;
    duration: number;
    blendable: boolean;
}
interface CameraPreset {
    id: string;
    name: string;
    position: {
        x: number;
        y: number;
        z: number;
    };
    rotation: {
        x: number;
        y: number;
        z: number;
    };
    fov: number;
    description: string;
}
declare class VRMIntegrationService {
    private availableAnimations;
    private expressions;
    private cameraPresets;
    getAvailableAnimations(tier?: 'free' | 'premium' | 'vip'): VRMAnimation[];
    getAnimationsByEmotion(emotion: string, tier?: 'free' | 'premium' | 'vip'): VRMAnimation[];
    getAnimationsByCategory(category: string, tier?: 'free' | 'premium' | 'vip'): VRMAnimation[];
    getRandomAnimation(emotion?: string, category?: string, tier?: 'free' | 'premium' | 'vip'): VRMAnimation | null;
    getExpression(id: string): VRMExpression | null;
    getExpressionByEmotion(emotion: string): VRMExpression | null;
    getCameraPreset(id: string): CameraPreset | null;
    getAllCameraPresets(): CameraPreset[];
    /**
     * Process a VRM control action and return the necessary data for execution
     */
    processVRMAction(action: VRMControlAction, userTier?: 'free' | 'premium' | 'vip'): {
        success: boolean;
        data?: any;
        error?: string;
    };
    /**
     * Process a camera control action
     */
    processCameraAction(action: CameraControlAction): {
        success: boolean;
        data?: any;
        error?: string;
    };
    /**
     * Get AI-suggested actions based on conversation context
     */
    suggestActionsForContext(message: string, emotion: string, userTier?: 'free' | 'premium' | 'vip'): Array<VRMControlAction | CameraControlAction>;
}

/**
 * Canvas Integration Service
 * Enables AI agents to generate and display images, effects, and overlays on the canvas
 */

interface CanvasElement {
    id: string;
    type: 'image' | 'text' | 'effect' | 'overlay';
    content: string;
    position: {
        x: number;
        y: number;
    };
    size: {
        width: number;
        height: number;
    };
    style: CanvasElementStyle;
    duration?: number;
    animation?: CanvasAnimation;
    layer: number;
    visible: boolean;
    createdAt: Date;
}
interface CanvasElementStyle {
    opacity: number;
    rotation: number;
    scale: number;
    color?: string;
    fontSize?: number;
    fontFamily?: string;
    filter?: string;
    borderRadius?: number;
    shadow?: {
        x: number;
        y: number;
        blur: number;
        color: string;
    };
}
interface CanvasAnimation {
    type: 'fade-in' | 'fade-out' | 'slide-in' | 'scale-in' | 'bounce' | 'pulse';
    duration: number;
    easing: 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out';
    delay?: number;
    repeat?: boolean;
}
interface ImagePromptTemplate {
    id: string;
    name: string;
    template: string;
    category: 'cute' | 'anime' | 'realistic' | 'artistic' | 'abstract';
    variables: string[];
    style: string;
}
declare class CanvasIntegrationService {
    private elements;
    private nextElementId;
    private nextLayer;
    private promptTemplates;
    /**
     * Process a canvas action and return the necessary data for execution
     */
    processCanvasAction(action: CanvasAction, imageProvider?: any, context?: Record<string, any>): Promise<{
        success: boolean;
        data?: any;
        error?: string;
    }>;
    private handleDrawAction;
    private handleClearAction;
    private handleOverlayAction;
    private handleBackgroundAction;
    private handleEffectAction;
    private generateImagePrompt;
    private findBestTemplate;
    private enhancePrompt;
    private getDefaultValue;
    private createElement;
    private createSparkleEffect;
    private createHeartsEffect;
    private createConfettiEffect;
    private createGlowEffect;
    private createRainEffect;
    getAllElements(): CanvasElement[];
    getElement(id: string): CanvasElement | null;
    removeElement(id: string): boolean;
    updateElement(id: string, updates: Partial<CanvasElement>): boolean;
    getPromptTemplates(): ImagePromptTemplate[];
    addPromptTemplate(template: ImagePromptTemplate): void;
}

/**
 * PartyKit adapter for AI Framework
 */

interface PartyKitMessage {
    type: string;
    payload: any;
}
declare class PartyKitAdapter {
    private conversationService;
    constructor(conversationService: ConversationService);
    handleMessage(message: PartyKitMessage): Promise<PartyKitMessage | null>;
    private handleAIRequest;
    private handleClearConversation;
    private serializeResponse;
    private createAudioUrl;
    formatBroadcast(response: AIResponse, roomId: string): PartyKitMessage;
}

/**
 * ai-agent-simple
 *
 * Modular AI framework for text generation, TTS, and more
 */

interface AIFrameworkConfig {
    providers?: {
        text?: ProviderConfig;
        tts?: ProviderConfig;
        image?: ProviderConfig;
    };
    conversation?: {
        enableTTS?: boolean;
        enableActions?: boolean;
        maxContextMessages?: number;
    };
}
declare class AIFramework {
    private config;
    private providers;
    private conversationService?;
    private partyKitAdapter?;
    constructor(config?: AIFrameworkConfig);
    initialize(): Promise<void>;
    getProvider(type: ProviderType): AIProvider | undefined;
    get conversation(): ConversationService;
    get partyKit(): PartyKitAdapter;
    processMessage(userId: string, message: string, personality?: PersonalityProfile, metadata?: Record<string, any>): Promise<AIResponse>;
}

export { AIFramework, type AIFrameworkConfig, AIFrameworkError, type AIProvider, type AIResponse, type AgentAction, AgentController, AkashText, AlkahestImage, AlkahestTTS, AlkahestText, AudioControlService, type AudioFormat, type AudioResponse, BaseProvider, CanvasIntegrationService, ConfigurationError, type ConversationContext, ConversationService, type ImageGenerationOptions, type ImageResponse, MahoText, type Message, OpenAITTS, OpenAIText, PartyKitAdapter, type PersonalityProfile, type ProviderConfig, ProviderError, ProviderManager, type ProviderType, RateLimitError, type TTSOptions, type TextGenerationOptions, type TextResponse, TipManagementService, type UsageStats, VRMIntegrationService, type Voice };