paprflare-sdk 0.0.18 → 0.0.19

package/dist/index.d.mts

@@ -1196,7 +1196,7 @@ declare function measureTime<T>(fn: () => Promise<T>): Promise<{
 }>;
 
 /**
- * StreamWriter Events with UI Animation Support
+ * StreamWriter Events
  */
 interface StreamWriterEvents {
     write: (text: string) => void;
@@ -1208,219 +1208,67 @@ interface StreamWriterEvents {
     }) => void;
     done: (message: any) => void;
     start: () => void;
-    pause: () => void;
-    resume: () => void;
-    progress: (data: ProgressData) => void;
-    thinking: (status: ThinkingStatus) => void;
     toolUse: (tool: ToolUseData) => void;
     toolResult: (result: ToolResultData) => void;
-    metadata: (meta: MetadataEvent) => void;
     chunk: (chunk: ChunkData) => void;
-    speed: (wpm: number) => void;
     statusChange: (status: StreamStatus) => void;
 }
 /**
  * Stream Status
  */
-type StreamStatus = 'idle' | 'starting' | 'streaming' | 'thinking' | 'tool_executing' | 'paused' | 'resuming' | 'completing' | 'done' | 'error';
-/**
- * Progress Data
- */
-interface ProgressData {
-    /** Current character count */
-    characters: number;
-    /** Current word count */
-    words: number;
-    /** Estimated completion percentage (0-100) */
-    percentage: number;
-    /** Time elapsed in ms */
-    elapsed: number;
-    /** Estimated time remaining in ms */
-    estimatedRemaining?: number;
-}
-/**
- * Thinking Status
- */
-interface ThinkingStatus {
-    /** Is currently thinking */
-    isThinking: boolean;
-    /** Thinking message/phase */
-    message?: string;
-    /** Duration in ms */
-    duration?: number;
-}
+type StreamStatus = 'idle' | 'starting' | 'streaming' | 'tool_executing' | 'completing' | 'done' | 'error';
 /**
  * Tool Use Data
  */
 interface ToolUseData {
-    /** Tool ID */
     id: string;
-    /** Tool name */
     name: string;
-    /** Tool input parameters */
     input: any;
-    /** Tool status */
     status: 'starting' | 'running' | 'completed' | 'failed';
-    /** Timestamp */
     timestamp: number;
 }
 /**
  * Tool Result Data
  */
 interface ToolResultData {
-    /** Tool ID */
     toolId: string;
-    /** Result content */
     content: any;
-    /** Success status */
     success: boolean;
-    /** Error message if failed */
     error?: string;
-    /** Execution duration in ms */
     duration: number;
-    /** Timestamp */
-    timestamp: number;
-}
-/**
- * Metadata Event
- */
-interface MetadataEvent {
-    /** Event type */
-    type: 'model' | 'temperature' | 'maxTokens' | 'custom';
-    /** Event data */
-    data: any;
-    /** Timestamp */
     timestamp: number;
 }
 /**
  * Chunk Data
  */
 interface ChunkData {
-    /** Chunk text */
     text: string;
-    /** Chunk index */
     index: number;
-    /** Chunk timestamp */
     timestamp: number;
-    /** Time since last chunk (ms) */
     deltaTime: number;
 }
-/**
- * Animation Options
- */
-interface AnimationOptions {
-    /** Enable typing animation effect */
-    typing?: boolean;
-    /** Typing speed in characters per second */
-    typingSpeed?: number;
-    /** Enable cursor animation */
-    cursor?: boolean;
-    /** Cursor character */
-    cursorChar?: string;
-    /** Cursor blink interval in ms */
-    cursorBlinkInterval?: number;
-    /** Enable smooth scroll */
-    smoothScroll?: boolean;
-    /** Enable word highlighting */
-    highlightWords?: boolean;
-    /** Highlight duration in ms */
-    highlightDuration?: number;
-}
-/**
- * Auto-output options
- */
-interface AutoOutputOptions {
-    /** Enable automatic console output (default: true) */
-    enabled?: boolean;
-    /** Show usage information (default: true) */
-    showUsage?: boolean;
-    /** Show final message (default: true) */
-    showFinalMessage?: boolean;
-    /** Show progress updates (default: true) */
-    showProgress?: boolean;
-    /** Progress update interval in ms (default: 500) */
-    progressInterval?: number;
-    /** Show thinking status (default: true) */
-    showThinking?: boolean;
-    /** Show tool execution (default: true) */
-    showTools?: boolean;
-    /** Show speed metrics (default: false) */
-    showSpeed?: boolean;
-    /** Animation options */
-    animation?: AnimationOptions;
-    /** Custom text output handler */
-    onText?: (text: string) => void;
-    /** Custom error handler */
-    onError?: (error: string) => void;
-    /** Custom usage handler */
-    onUsage?: (tokens: {
-        prompt: number;
-        completion: number;
-        total: number;
-    }) => void;
-    /** Custom done handler */
-    onDone?: (message: any) => void;
-    /** Custom progress handler */
-    onProgress?: (data: ProgressData) => void;
-    /** Custom thinking handler */
-    onThinking?: (status: ThinkingStatus) => void;
-    /** Custom tool use handler */
-    onToolUse?: (tool: ToolUseData) => void;
-    /** Custom tool result handler */
-    onToolResult?: (result: ToolResultData) => void;
-    /** Custom status change handler */
-    onStatusChange?: (status: StreamStatus) => void;
-}
 
 /**
- * Enhanced StreamWriter with UI Animation Support
- * Provides real-time events for live UI updates and animations
+ * StreamWriter for handling streaming text and tool execution
+ * Provides real-time events for live UI updates
  */
 declare class StreamWriter extends EventEmitter$1<StreamWriterEvents> {
     private events;
     private closed;
     private fullText;
-    private autoOutput;
-    private animation;
-    private status;
     private startTime;
     private lastChunkTime;
     private chunkIndex;
-    private paused;
-    private pauseStartTime;
-    private totalPauseDuration;
-    private progressInterval?;
-    private speedCalculationWindow;
-    private currentWPM;
-    private thinkingStartTime?;
+    private status;
     private activeTools;
     private currentToolCall;
-    private cursorInterval?;
-    private typingQueue;
-    private isTyping;
-    constructor(options?: AutoOutputOptions);
-    /**
-     * Default handlers
-     */
-    private defaultTextHandler;
-    private defaultErrorHandler;
-    private defaultUsageHandler;
-    private defaultDoneHandler;
-    private defaultProgressHandler;
-    private defaultThinkingHandler;
-    private defaultToolUseHandler;
-    private defaultToolResultHandler;
-    private defaultStatusChangeHandler;
-    /**
-     * Set up automatic event listeners
-     */
-    private setupAutoListeners;
+    constructor();
     /**
      * Start the stream
      */
     start(): void;
     /**
-     * Write text content (method used by providers)
+     * Write text content
      */
     writeText(text: string): void;
     /**
@@ -1439,34 +1287,30 @@ declare class StreamWriter extends EventEmitter$1<StreamWriterEvents> {
      * End a tool call with final arguments
      */
     endToolCall(args: Record<string, unknown>): void;
-    /**
-     * Write usage information
-     */
-    writeUsage(tokens: {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    }): void;
-    /**
-     * Set thinking status
-     */
-    setThinking(isThinking: boolean, message?: string): void;
     /**
      * Legacy startTool method (for backward compatibility)
      */
     startTool(id: string, name: string, input: any): void;
     /**
-     * Legacy completeTool method (for backward compatibility)
+     * Complete a tool (legacy method for backward compatibility)
      */
     completeTool(toolId: string, content: any, success?: boolean, error?: string): void;
     /**
-     * Pause the stream
+     * Write usage information
      */
-    pause(): void;
+    writeUsage(tokens: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    }): void;
     /**
-     * Resume the stream
+     * Legacy usage method (for backward compatibility)
      */
-    resume(): void;
+    usage(tokens: {
+        prompt: number;
+        completion: number;
+        total: number;
+    }): void;
     /**
      * Write error
      */
@@ -1480,18 +1324,6 @@ declare class StreamWriter extends EventEmitter$1<StreamWriterEvents> {
      * Mark stream as done
      */
     done(finalMessage?: any): void;
-    /**
-     * Legacy usage method (for backward compatibility)
-     */
-    usage(tokens: {
-        prompt: number;
-        completion: number;
-        total: number;
-    }): void;
-    /**
-     * Add custom metadata
-     */
-    metadata(type: MetadataEvent['type'], data: any): void;
     /**
      * Update stream status
      */
@@ -1500,46 +1332,10 @@ declare class StreamWriter extends EventEmitter$1<StreamWriterEvents> {
      * Get current status
      */
     getStatus(): StreamStatus;
-    /**
-     * Start progress tracking
-     */
-    private startProgressTracking;
-    /**
-     * Update speed calculation
-     */
-    private updateSpeed;
-    /**
-     * Typing animation
-     */
-    private queueTyping;
-    private processTypingQueue;
-    /**
-     * Cursor animation
-     */
-    private startCursorAnimation;
-    private stopCursorAnimation;
-    /**
-     * Helper methods
-     */
-    private countWords;
-    private createProgressBar;
-    private sleep;
-    /**
-     * Get current speed (WPM)
-     */
-    getSpeed(): number;
-    /**
-     * Get progress data
-     */
-    getProgress(): ProgressData;
     /**
      * Check if stream is closed
      */
     isClosed(): boolean;
-    /**
-     * Check if stream is paused
-     */
-    isPaused(): boolean;
     /**
      * Get accumulated text
      */
@@ -1548,31 +1344,23 @@ declare class StreamWriter extends EventEmitter$1<StreamWriterEvents> {
      * Get active tools
      */
     getActiveTools(): ToolUseData[];
-    /**
-     * Convert to async generator (legacy method)
-     */
-    toGenerator(): AsyncGenerator<StreamEvent>;
     /**
      * Get all events
      */
     getEvents(): StreamEvent[];
     /**
-     * Reset the writer
-     */
-    reset(): void;
-    /**
-     * Disable auto-output
+     * Convert to async generator (legacy method)
      */
-    disableAutoOutput(): void;
+    toGenerator(): AsyncGenerator<StreamEvent>;
     /**
-     * Enable auto-output
+     * Reset the writer
      */
-    enableAutoOutput(): void;
+    reset(): void;
 }
 /**
  * Create StreamWriter instance
  */
-declare function createStreamWriter(options?: AutoOutputOptions): StreamWriter;
+declare function createStreamWriter(): StreamWriter;
 
 /**
  * Parse SSE stream into structured events
@@ -1667,12 +1455,6 @@ type UIStreamEvent = {
 } | {
     type: 'message-complete';
     message: UIMessage;
-} | {
-    type: 'progress';
-    progress: ProgressData;
-} | {
-    type: 'thinking';
-    status: ThinkingStatus;
 } | {
     type: 'status-change';
     status: StreamStatus;
@@ -1714,8 +1496,6 @@ interface StreamHandlers {
         completion: number;
         total: number;
     }) => void | Promise<void>;
-    onProgress?: (progress: ProgressData) => void | Promise<void>;
-    onThinking?: (status: ThinkingStatus) => void | Promise<void>;
     onStatusChange?: (status: StreamStatus) => void | Promise<void>;
 }
 /**
@@ -1742,7 +1522,6 @@ declare function processStream(stream: AsyncGenerator<StreamEvent>, handlers: St
 declare function collectText(stream: AsyncGenerator<StreamEvent>): Promise<string>;
 /**
  * Create UI message stream with advanced control and live updates
- * Similar to Vercel AI SDK's createStreamableUI
  *
  * @example
  * const stream = createUIMessageStream({
@@ -1767,37 +1546,17 @@ declare function createUIMessageStream(options: {
     onFinish?: (result: {
         message: UIMessage;
     }) => void | Promise<void>;
-    onProgress?: (progress: ProgressData) => void | Promise<void>;
-    onThinking?: (status: ThinkingStatus) => void | Promise<void>;
     onToolUse?: (tool: ToolUseData) => void | Promise<void>;
     onToolResult?: (result: ToolResultData) => void | Promise<void>;
     onStatusChange?: (status: StreamStatus) => void | Promise<void>;
-    onSpeed?: (wpm: number) => void | Promise<void>;
-    writerOptions?: Partial<AutoOutputOptions>;
 }): AsyncGenerator<UIStreamEvent>;
 /**
- * Stream to console with formatting and live updates
+ * Stream to console with formatting
  *
  * @example
- * await streamToConsole(response.stream, {
- *   showUsage: true,
- *   showProgress: true,
- *   showThinking: true,
- * });
+ * await streamToConsole(response.stream);
  */
-declare function streamToConsole(stream: AsyncGenerator<StreamEvent>, options?: {
-    showUsage?: boolean;
-    showProgress?: boolean;
-    showThinking?: boolean;
-    showTools?: boolean;
-    showSpeed?: boolean;
-    colors?: boolean;
-    animation?: {
-        typing?: boolean;
-        typingSpeed?: number;
-        cursor?: boolean;
-    };
-}): Promise<void>;
+declare function streamToConsole(stream: AsyncGenerator<StreamEvent>): Promise<void>;
 /**
  * Convert stream to HTTP Response (one-liner for API routes)
  * Works with Next.js, Express, Node.js HTTP, etc.
@@ -1818,7 +1577,7 @@ declare function streamToConsole(stream: AsyncGenerator<StreamEvent>, options?:
  */
 declare function toHTTPResponse(stream: AsyncGenerator<StreamEvent>, target?: any): Promise<Response | void>;
 /**
- * Create a streamable value (like Vercel AI SDK)
+ * Create a streamable value
  *
  * @example
  * const stream = createStreamableValue('initial');