chat-flow-ardymalihi 1.0.2 → 3.0.2

package/dist/src/interfaces.d.ts

@@ -0,0 +1,663 @@
+export declare enum Role {
+    USER = "user",
+    ASSISTANT = "assistant",
+    SYSTEM = "system"
+}
+export declare enum SessionStatus {
+    ACTIVE = "ACTIVE",
+    WAITING_FOR_WORKFLOW = "WAITING_FOR_WORKFLOW",
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED"
+}
+export type ConversationMode = 'collaborative' | 'strict';
+import { z } from "zod";
+export interface EventVariable {
+    label: string;
+    description?: string;
+    path: string;
+    type?: 'string' | 'number' | 'boolean' | 'object' | 'array';
+}
+export interface EventDefinition {
+    type: string;
+    label: string;
+    description?: string;
+    source: string;
+    variables: EventVariable[];
+    schema?: z.ZodType<any>;
+}
+export interface WebhookEvent {
+    id: number | string;
+    created_at: string;
+    type: string;
+    payload: Record<string, any>;
+    source: string;
+    userId: string | null;
+    status: 'pending' | 'processed' | 'failed' | string;
+    error_message: string | null;
+}
+export interface WorkflowStep {
+    id: string;
+    action: string;
+    input: Record<string, any>;
+    nextStepId?: string | null;
+    condition?: string;
+    trueStepId?: string | null;
+    falseStepId?: string | null;
+    description?: string;
+    position?: {
+        x: number;
+        y: number;
+    };
+}
+export interface Workflow {
+    id: string;
+    userId: string;
+    name: string;
+    description: string | null;
+    event_type: string;
+    definition: WorkflowStep[];
+    configs?: Record<string, any> | null;
+    is_active: boolean;
+    created_at: string;
+    updated_at: string;
+    viewport?: {
+        x: number;
+        y: number;
+        zoom: number;
+        showMiniMap?: boolean;
+    };
+    priority?: number;
+    workflow_cron_configs?: {
+        cron_schedule: string;
+        next_run_at: string;
+    }[] | {
+        cron_schedule: string;
+        next_run_at: string;
+    };
+}
+export interface WorkflowExecution {
+    id: string;
+    workflow_id: string;
+    userId: string;
+    event_type: string;
+    event_payload: any;
+    status: 'pending' | 'processing' | 'success' | 'failed';
+    started_at: string;
+    completed_at?: string | null;
+    error_message?: string | null;
+    last_failed_step_id?: string | null;
+    priority?: number;
+    outputResult?: string;
+    workflow_action_logs?: WorkflowActionLog[];
+    step_logs?: string[];
+    workflows?: Workflow;
+}
+export interface WorkflowActionLog {
+    id: string;
+    workflow_id: string | null;
+    userId: string;
+    execution_id: string;
+    step_id: string | null;
+    action_type: string;
+    input: any;
+    output: any;
+    status: string;
+    error_message: string | null;
+    started_at: string;
+    completed_at: string | null;
+}
+export interface ActionContext {
+    workflow_id: string;
+    execution_id: string;
+    step_id: string;
+    userId: string;
+    settings?: Record<string, any>;
+    credentials?: Record<string, any>;
+    appendOutput: (text: string) => void;
+}
+export interface ActionResult<T = any> {
+    data?: T | null;
+    error: any;
+}
+export type ActionFunction<TInput = any, TOutput = any> = (input: TInput, context: ActionContext) => Promise<ActionResult<TOutput>>;
+export interface ActionDefinition<TInput = any, TOutput = any> {
+    id: string;
+    name: string;
+    description?: string;
+    iconName?: string;
+    isActive?: boolean;
+    providers?: string[];
+    inputSchema?: z.ZodType<TInput>;
+    outputSchema?: z.ZodType<TOutput>;
+    handler: ActionFunction<TInput, TOutput>;
+}
+export type IntegrationSettingType = 'string' | 'number' | 'boolean';
+export interface IntegrationSettingDef {
+    key: string;
+    label: string;
+    type: IntegrationSettingType;
+    defaultValue?: any;
+    required?: boolean;
+    description?: string;
+    scope?: 'connection' | 'configuration' | 'both';
+}
+export interface IntegrationCredential {
+    access_token?: string;
+    refresh_token?: string;
+    expires_at?: number;
+    scope?: string;
+    token_type?: string;
+    client_id?: string;
+    client_secret?: string;
+    [key: string]: any;
+}
+export interface IntegrationDefinition {
+    provider: string;
+    displayName: string;
+    description: string;
+    iconName: string;
+    getConnectUrl(userId: string): Promise<string> | string;
+    handleCallback(params: {
+        userId: string;
+        searchParams: URLSearchParams;
+        body?: any;
+    }): Promise<void>;
+    isConnected(userId: string, credential?: IntegrationCredential): Promise<boolean>;
+    disconnect(userId: string): Promise<void>;
+    getClient(userId: string): Promise<any>;
+    getSettings?(): IntegrationSettingDef[];
+}
+export interface VariableDefinition {
+    path: string;
+    label: string;
+    type?: string;
+    description?: string;
+}
+export interface VariableGroup {
+    id: string;
+    name: string;
+    icon?: string;
+    color?: string;
+    variables: VariableDefinition[];
+}
+export interface WorkflowTemplate {
+    id: string;
+    name: string;
+    description: string;
+    event_type: string;
+    definition: WorkflowStep[];
+    metadata: {
+        stepCount: number;
+        providers: string[];
+    };
+}
+export declare enum ConversationWebhookEvent {
+    SESSION_STARTED = "conversation.session.started",
+    SESSION_ENDED = "conversation.session.ended",
+    MESSAGE_USER = "conversation.message.user",
+    MESSAGE_BOT = "conversation.message.bot",
+    INTENT_DETECTED = "conversation.intent.detected",
+    INTENT_FAILED = "conversation.intent.failed",
+    WORKFLOW_EXECUTED = "conversation.workflow.executed",
+    WORKFLOW_FAILED = "conversation.workflow.failed",
+    ERROR_OCCURRED = "conversation.error.occurred"
+}
+export interface WebhookConfig {
+    url: string;
+    events: ConversationWebhookEvent[];
+    headers?: Record<string, string>;
+}
+export interface Message {
+    role: Role;
+    content: string;
+    timestamp: Date;
+    metadata?: Record<string, any>;
+}
+export interface User {
+    id: string;
+    name: string;
+    apiKey: string;
+    metadata?: Record<string, any>;
+}
+export interface ConversationConfig {
+    id: string;
+    userId: string;
+    systemPrompt: string;
+    voiceConfig?: VoiceConfig;
+    allowedIntents?: string[];
+    allowedOrigins?: string[];
+    metadata?: Record<string, any>;
+    uiConfig?: UIConfig;
+    blacklistedWords?: string[];
+    exitPhrases?: string[];
+    multiLingualMode?: boolean;
+    defaultLanguage?: string;
+    supportedLanguages?: string[];
+    languageVoiceMapping?: Record<string, string>;
+    webhook?: WebhookConfig;
+}
+export interface UIConfig {
+    width?: string;
+    height?: string;
+    theme?: 'light' | 'dark';
+    primaryColor?: string;
+    companyLogoUrl?: string;
+    micIcon?: 'default' | 'robot';
+    layoutMode?: 'default' | 'compact' | 'mic-only';
+    showTranscript?: boolean;
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    collapsible?: boolean;
+    autoExpanded?: boolean;
+    showStatus?: boolean;
+    title?: string;
+    subtitle?: string;
+    borderRadius?: 'none' | 'small' | 'full';
+    boxShadow?: 'none' | 'soft' | 'strong';
+    transparency?: 'low' | 'medium' | 'high';
+    sessionMode?: 'voice' | 'text';
+}
+export interface Field {
+    name: string;
+    type: string;
+    description?: string;
+    displayName?: string;
+    default_value?: any;
+}
+export interface ParameterCollectionState {
+    intentName: string;
+    detectedParameters: Record<string, any>;
+    missingParameters: string[];
+    attemptCount: number;
+    initialConfidence: number;
+}
+export interface Intent {
+    id?: number;
+    userId?: string;
+    name: string;
+    description: string;
+    required_fields: Field[];
+    optional_fields?: Field[];
+    processingMessages?: string[];
+    skipWorkflow?: boolean;
+}
+export interface MatchedIntent {
+    intent: Intent;
+    confidence: number;
+    required_values: Record<string, any>;
+    optional_values: Record<string, any>;
+}
+export interface IntentResult {
+    intentName: string | null;
+    confidence: number;
+    payload?: Record<string, any>;
+    missingRequiredParameters?: string[];
+    rawResponse?: any;
+}
+export interface IIntentService {
+    /**
+     * Analyzes the conversation history and latest message to detect user intent.
+     * @param history Full conversation history or relevant window.
+     * @param systemPrompt Context for the intent detector.
+     */
+    detectIntent(history: Message[], systemPrompt: string, userId?: string): Promise<IntentResult>;
+    /**
+     * Match intents against a context string or object.
+     * Used for looking up intent definitions during parameter collection.
+     * @param context Context to match against
+     * @param confidenceThreshold Optional confidence threshold
+     */
+    matchIntents(context: string | object, confidenceThreshold?: number): Promise<MatchedIntent[]>;
+}
+import { ConversationSession } from './core/entities/ConversationSession';
+export interface IRepository {
+    saveSession(session: ConversationSession): Promise<void>;
+    findSessionById(sessionId: string): Promise<ConversationSession | null>;
+    findUserById(id: string): Promise<User | null>;
+    saveConversationConfig(config: ConversationConfig): Promise<void>;
+    findConversationConfig(userId: string, configId?: string): Promise<ConversationConfig | null>;
+    getAllConversationConfigs(userId: string): Promise<ConversationConfig[]>;
+    saveIntent(intent: Intent): Promise<void>;
+    upsertIntents(intents: Intent[]): Promise<void>;
+    /**
+     * Find intent by name, checking user scope first, then global
+     */
+    findIntentByName(name: string, userId?: string): Promise<Intent | null>;
+    /**
+     * Get all intents available to a user (User Specific + Global)
+     */
+    getAllIntents(userId?: string): Promise<Intent[]>;
+    deleteIntent(name: string, userId?: string): Promise<void>;
+    saveWorkflow(workflow: Workflow): Promise<string>;
+    findWorkflowById(id: string, userId: string): Promise<Workflow | null>;
+    getAllWorkflows(userId: string): Promise<Workflow[]>;
+    getActiveWorkflowsForEvent(userId: string, eventType: string): Promise<Workflow[]>;
+    deleteWorkflow(id: string, userId: string): Promise<void>;
+    createWorkflowExecution(execution: Partial<WorkflowExecution>): Promise<WorkflowExecution>;
+    updateWorkflowExecution(executionId: string, updates: Partial<WorkflowExecution>): Promise<void>;
+    getWorkflowExecutionById(executionId: string): Promise<WorkflowExecution | null>;
+    getWorkflowExecutionWithLogs(executionId: string): Promise<WorkflowExecution & {
+        workflow_action_logs: WorkflowActionLog[];
+        workflow: Workflow;
+    }>;
+    getPendingWorkflowExecutions(limit: number): Promise<WorkflowExecution[]>;
+    getActiveWorkflowExecutionCount(workflowId: string): Promise<number>;
+    markWorkflowExecutionFailed(executionId: string, error: string): Promise<void>;
+    logWorkflowAction(logEntry: Partial<WorkflowActionLog>): Promise<WorkflowActionLog>;
+    getWorkflowExecutionLogs(executionId: string): Promise<WorkflowActionLog[]>;
+    storeWebhookEvent(event: Partial<WebhookEvent>): Promise<number>;
+    getWebhookEvent(id: number): Promise<WebhookEvent | null>;
+    updateWebhookEventStatus(id: number, updates: Partial<WebhookEvent>): Promise<void>;
+    getDueScheduledWorkflows(now: Date): Promise<Workflow[]>;
+    updateWorkflowSchedule(workflowId: string, nextRun: Date): Promise<void>;
+    getAllSessions(userId: string, limit?: number, offset?: number): Promise<{
+        sessions: ConversationSession[];
+        total: number;
+    }>;
+    getAllExecutions(userId: string, limit?: number, offset?: number): Promise<{
+        executions: WorkflowExecution[];
+        total: number;
+    }>;
+    disconnect(): Promise<void>;
+}
+export interface LLMResponse {
+    content: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+    };
+}
+export interface ILLMAdapter {
+    generateResponse(prompt: string, history: Message[]): Promise<LLMResponse>;
+    generateContent?(prompt: string): Promise<string>;
+}
+export interface VoiceConfig {
+    stt?: {
+        provider: 'google' | 'azure' | 'aws' | 'deepgram' | 'whisper' | 'custom';
+        language: string;
+        encoding?: 'LINEAR16' | 'FLAC' | 'WAV';
+        sampleRateHertz?: number;
+        autoDetectLanguage?: boolean;
+        languageHints?: string[];
+    };
+    tts?: {
+        provider: 'google' | 'azure' | 'aws' | 'elevenlabs' | 'custom';
+        voice: string;
+        language: string;
+        speakingRate?: number;
+        pitch?: number;
+        multiLingualVoices?: Record<string, string>;
+    };
+    silenceThresholdMs?: number;
+    smartMode?: boolean;
+    interruptionMode?: 'off' | 'click_only' | 'voice_barge_in';
+}
+export interface AudioMetadata {
+    duration_ms?: number;
+    transcript_confidence?: number;
+    audio_encoding?: string;
+    sample_rate?: number;
+}
+/**
+ * Audio Format Metadata
+ * Declares the audio format produced/consumed by voice adapters
+ * Used by IAudioStorage to convert between different formats
+ */
+export interface AudioFormatMetadata {
+    format: 'wav' | 'mp3' | 'pcm' | 'aac' | 'ogg';
+    sampleRate?: number;
+    channels?: number;
+    bitDepth?: number;
+}
+/**
+ * Voice Adapter Interface
+ * Handles speech-to-text and text-to-speech operations
+ * Separate from LLM adapter for flexibility (e.g., use Gemini for AI but local TTS/STT)
+ */
+export interface IVoiceAdapter {
+    /**
+     * Convert speech (audio) to text
+     * @param audioBase64 Base64-encoded audio data
+     * @param config Optional STT configuration
+     * @returns Transcribed text
+     */
+    speechToText(audioBase64: string, config?: VoiceConfig['stt']): Promise<string>;
+    /**
+     * Convert text to speech (audio)
+     * @param text Text to convert to speech
+     * @param config Optional TTS configuration
+     * @returns Audio data as Uint8Array
+     */
+    textToSpeech(text: string, config?: VoiceConfig['tts']): Promise<Uint8Array>;
+    /**
+     * Get the audio format metadata for TTS output
+     * This is used by IAudioStorage to properly convert and store audio
+     */
+    getTTSOutputFormat(): AudioFormatMetadata;
+    /**
+     * Get the expected audio format metadata for STT input
+     * Optional - if not provided, storage adapter will assume WAV format
+     */
+    getSTTInputFormat?(): AudioFormatMetadata;
+}
+export interface WorkflowResult {
+    success: boolean;
+    data?: any;
+    userMessage?: string;
+    error?: string;
+}
+export interface IOrchestrator {
+    createSession(sessionId: string, mode: 'TEXT' | 'VOICE', agentPrompt: string, userId?: string, configId?: string): Promise<ConversationSession>;
+    processMessage(sessionId: string, content: string, onIntermediateResponse?: (text: string) => Promise<void>): Promise<{
+        messages: Message[];
+        metadata?: any;
+    }>;
+    completeSession(sessionId: string, recordingUrl?: string): Promise<ConversationSession>;
+}
+export interface IWorkflowAdapter {
+    executeWorkflow(workflowId: string, context: any): Promise<WorkflowResult>;
+}
+export interface WebhookPayloadBase {
+    eventId: string;
+    eventType: ConversationWebhookEvent;
+    timestamp: string;
+    session: {
+        sessionId: string;
+        userId?: string;
+        configId?: string;
+        mode: 'TEXT' | 'VOICE';
+        channel: string;
+        conversationMode: ConversationMode;
+        status: SessionStatus;
+        startedAt: string;
+        endedAt?: string;
+        durationMs?: number;
+        language?: string;
+    };
+    conversation: {
+        totalMessages: number;
+        userMessages: number;
+        botMessages: number;
+    };
+}
+export interface SessionStartedWebhookPayload extends WebhookPayloadBase {
+    eventType: ConversationWebhookEvent.SESSION_STARTED;
+}
+export interface SessionEndedWebhookPayload extends WebhookPayloadBase {
+    eventType: ConversationWebhookEvent.SESSION_ENDED;
+    conversation: WebhookPayloadBase['conversation'] & {
+        messages: Array<{
+            role: string;
+            content: string;
+            timestamp: string;
+            metadata?: Record<string, any>;
+        }>;
+        summary?: string;
+        detectedIntents?: Array<{
+            intentName: string;
+            confidence: number;
+            timestamp: string;
+            triggerId?: string;
+            result?: any;
+        }>;
+        executedWorkflows?: Array<{
+            workflowName: string;
+            result?: any;
+            timestamp: string;
+            triggerId?: string;
+            executionId?: string;
+        }>;
+        timestamp: string;
+    };
+    recordingUrl?: string;
+}
+export interface MessageUserWebhookPayload extends WebhookPayloadBase {
+    eventType: ConversationWebhookEvent.MESSAGE_USER;
+    data: {
+        message: {
+            role: string;
+            content: string;
+            timestamp: string;
+            metadata?: Record<string, any>;
+        };
+    };
+}
+export interface MessageBotWebhookPayload extends WebhookPayloadBase {
+    eventType: ConversationWebhookEvent.MESSAGE_BOT;
+    data: {
+        message: {
+            role: string;
+            content: string;
+            timestamp: string;
+        };
+    };
+}
+export interface IntentDetectedWebhookPayload extends WebhookPayloadBase {
+    eventType: ConversationWebhookEvent.INTENT_DETECTED;
+    data: {
+        intent: {
+            intentName: string;
+            confidence: number;
+            parameters?: Record<string, any>;
+            missingParameters?: string[];
+        };
+    };
+}
+export interface IntentFailedWebhookPayload extends WebhookPayloadBase {
+    eventType: ConversationWebhookEvent.INTENT_FAILED;
+    data: {
+        intent: {
+            intentName: string;
+            confidence: number;
+        };
+    };
+}
+export interface WorkflowExecutedWebhookPayload extends WebhookPayloadBase {
+    eventType: ConversationWebhookEvent.WORKFLOW_EXECUTED;
+    data: {
+        workflow: {
+            workflowName: string;
+            parameters: Record<string, any>;
+            result: WorkflowResult;
+        };
+    };
+}
+export interface WorkflowFailedWebhookPayload extends WebhookPayloadBase {
+    eventType: ConversationWebhookEvent.WORKFLOW_FAILED;
+    data: {
+        workflow: {
+            workflowName: string;
+            parameters: Record<string, any>;
+            error?: string;
+        };
+    };
+}
+export interface ErrorOccurredWebhookPayload extends WebhookPayloadBase {
+    eventType: ConversationWebhookEvent.ERROR_OCCURRED;
+    data: {
+        error: {
+            message: string;
+            code?: string;
+            stack?: string;
+        };
+    };
+}
+export type WebhookPayload = SessionStartedWebhookPayload | SessionEndedWebhookPayload | MessageUserWebhookPayload | MessageBotWebhookPayload | IntentDetectedWebhookPayload | IntentFailedWebhookPayload | WorkflowExecutedWebhookPayload | WorkflowFailedWebhookPayload | ErrorOccurredWebhookPayload;
+export interface IWebhookService {
+    triggerSessionStarted(session: ConversationSession): Promise<void>;
+    triggerSessionEnded(session: ConversationSession, recordingUrl?: string): Promise<void>;
+    triggerUserMessage(session: ConversationSession, message: Message): Promise<void>;
+    triggerBotMessage(session: ConversationSession, message: Message): Promise<void>;
+    triggerIntentDetected(session: ConversationSession, intent: IntentResult): Promise<void>;
+    triggerIntentFailed(session: ConversationSession, intent: IntentResult): Promise<void>;
+    triggerWorkflowExecuted(session: ConversationSession, workflow: {
+        workflowName: string;
+        parameters: any;
+        result: WorkflowResult;
+    }): Promise<void>;
+    triggerWorkflowFailed(session: ConversationSession, workflow: {
+        workflowName: string;
+        parameters: any;
+        error?: string;
+    }): Promise<void>;
+    triggerErrorOccurred(session: ConversationSession, error: Error): Promise<void>;
+}
+export interface ConversationSessionProps {
+    sessionId: string;
+    mode: 'TEXT' | 'VOICE';
+    agentPrompt: string;
+    messages: any[];
+    status: SessionStatus;
+    createdAt: Date;
+    updatedAt: Date;
+    metadata?: Record<string, any>;
+}
+export interface MessageProps {
+    role: Role;
+    content: string;
+    timestamp: Date;
+    metadata?: Record<string, any>;
+}
+export interface CreateSessionProps {
+    sessionId: string;
+    mode: 'TEXT' | 'VOICE';
+    agentPrompt: string;
+    userId?: string;
+    configId?: string;
+    conversationMode?: ConversationMode;
+}
+export interface IAudioStorage {
+    initializeSession(sessionId: string, metadata: any): Promise<void>;
+    appendAudio(sessionId: string, audioData: Buffer, formatMetadata?: AudioFormatMetadata): Promise<void>;
+    finalizeSession(sessionId: string): Promise<string>;
+    getAudioUrl(sessionId: string): Promise<string | null>;
+    getSessionAudio(sessionId: string): Promise<Buffer | null>;
+}
+/**
+ * Logger interface for workflow engine
+ */
+export interface WorkflowLogger {
+    log(message: string, meta?: any): void;
+    warn(message: string, meta?: any): void;
+    error(message: string, meta?: any): void;
+}
+/**
+ * Provider for integration credentials and settings.
+ * The SDK implements this to inject integration data into the workflow engine.
+ * This decouples the engine from any specific credential storage mechanism.
+ */
+export interface IntegrationProvider {
+    /**
+     * Get all credentials for a user's integrations.
+     * @param userId - The user ID to fetch credentials for
+     * @returns Map of provider name to credential data (e.g., { google: { accessToken: '...' } })
+     */
+    getCredentials(userId: string): Promise<Record<string, any>>;
+    /**
+     * Get safe settings (credentials + defaults) for a user.
+     * Merges user credentials with default settings from SettingsRegistry.
+     * @param userId - The user ID to fetch settings for
+     * @returns Map of provider name to settings (e.g., { google: { apiKey: '...', timeout: 30 } })
+     */
+    getSafeSettings(userId: string): Promise<Record<string, any>>;
+}
+//# sourceMappingURL=interfaces.d.ts.map