openviber 0.4.3

package/dist/index.d.cts

@@ -0,0 +1,1691 @@
+import { ModelMessage, LanguageModel } from 'ai';
+export { Output, ToolLoopAgent, generateText, stepCountIs, streamText } from 'ai';
+import * as _openrouter_ai_sdk_provider from '@openrouter/ai-sdk-provider';
+import * as _ai_sdk_deepseek from '@ai-sdk/deepseek';
+import * as _ai_sdk_openai from '@ai-sdk/openai';
+import { z } from 'zod';
+import * as zustand from 'zustand';
+import { EventEmitter } from 'events';
+
+/**
+ * Task - Individual execution units within a space
+ */
+declare enum TaskStatus {
+    PENDING = "pending",
+    RUNNING = "running",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    BLOCKED = "blocked",
+    CANCELLED = "cancelled"
+}
+interface TaskStep {
+    id: string;
+    description: string;
+    status: TaskStatus;
+    startedAt?: Date;
+    completedAt?: Date;
+    error?: string;
+}
+interface TaskDependency {
+    taskId: string;
+    type: "required" | "optional";
+}
+declare class Task$1 {
+    id: string;
+    title: string;
+    description: string;
+    status: TaskStatus;
+    assignedTo?: string;
+    priority: "low" | "medium" | "high";
+    estimatedTime?: string;
+    actualTime?: string;
+    dependencies: TaskDependency[];
+    steps: TaskStep[];
+    tags: string[];
+    metadata: Record<string, any>;
+    createdAt: Date;
+    updatedAt: Date;
+    startedAt?: Date;
+    completedAt?: Date;
+    error?: string;
+    constructor({ id, title, description, status, assignedTo, priority, estimatedTime, dependencies, steps, tags, metadata, }: {
+        id: string;
+        title: string;
+        description: string;
+        status?: TaskStatus;
+        assignedTo?: string;
+        priority?: "low" | "medium" | "high";
+        estimatedTime?: string;
+        dependencies?: TaskDependency[];
+        steps?: TaskStep[];
+        tags?: string[];
+        metadata?: Record<string, any>;
+    });
+    start(): void;
+    complete(): void;
+    fail(error: string): void;
+    block(reason: string): void;
+    cancel(): void;
+    isActionable(context?: {
+        getTaskStatus: (id: string) => TaskStatus | undefined;
+    }): boolean;
+    hasBlockingDependencies(context?: {
+        getTaskStatus: (id: string) => TaskStatus | undefined;
+    }): boolean;
+    private calculateDuration;
+    toJSON(): any;
+    static fromJSON(data: any): Task$1;
+}
+
+/**
+ * Plan - Manages the execution plan for a space
+ */
+
+interface PlanSummary {
+    totalTasks: number;
+    completedTasks: number;
+    runningTasks: number;
+    pendingTasks: number;
+    failedTasks: number;
+    blockedTasks: number;
+    progressPercentage: number;
+}
+declare class Plan {
+    tasks: Task$1[];
+    goal: string;
+    createdAt: Date;
+    updatedAt: Date;
+    constructor({ tasks, goal }: {
+        tasks?: Task$1[];
+        goal: string;
+    });
+    addTask(task: Task$1): void;
+    removeTask(taskId: string): boolean;
+    getTaskById(taskId: string): Task$1 | undefined;
+    updateTaskStatus(taskId: string, status: TaskStatus): boolean;
+    getNextActionableTask(): Task$1 | undefined;
+    getAllActionableTasks(maxTasks?: number): Task$1[];
+    getTasksByStatus(status: TaskStatus): Task$1[];
+    getTasksByAssignee(assignee: string): Task$1[];
+    isComplete(): boolean;
+    hasFailedTasks(): boolean;
+    hasBlockedTasks(): boolean;
+    getProgressSummary(): PlanSummary;
+    reorderTasks(fromIndex: number, toIndex: number): void;
+    toJSON(): any;
+    static fromJSON(data: any): Plan;
+}
+
+/**
+ * Shared types for Viber engine
+ */
+interface ViberError extends Error {
+    code: string;
+    details?: any;
+}
+interface StreamChunk {
+    type: 'text' | 'tool_call' | 'tool_result' | 'error' | 'done';
+    content?: string;
+    tool?: {
+        name: string;
+        args: any;
+        result?: any;
+    };
+    error?: ViberError;
+}
+interface ModelConfig$2 {
+    provider: 'openai' | 'anthropic' | 'deepseek' | 'local';
+    model: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+interface StorageConfig {
+    type: 'local' | 'supabase';
+    basePath?: string;
+    supabaseUrl?: string;
+    supabaseKey?: string;
+}
+interface ViberConfig {
+    storage: StorageConfig;
+    model: ModelConfig$2;
+    streaming?: boolean;
+    debug?: boolean;
+}
+/**
+ * Space configuration - defines what the space is and how it works
+ */
+interface SpaceConfig {
+    name: string;
+    description?: string;
+    icon?: string;
+    agents?: string[];
+    agentPool?: string[];
+    tools?: string[];
+    datasets?: string[];
+    quickMessages?: string[];
+    metadata?: Record<string, any>;
+    [key: string]: any;
+}
+/**
+ * Internal persistence format - what Viber saves to disk
+ */
+interface SpaceModel {
+    spaceId: string;
+    name: string;
+    goal: string;
+    createdAt: string;
+    updatedAt: string;
+    teamAgents: string[];
+    plan?: any;
+    artifacts?: any[];
+}
+/**
+ * Running space status - exposed to UI layer
+ * Shows real-time progress and task information
+ */
+interface SpaceState {
+    spaceId: string;
+    name: string;
+    goal: string;
+    createdAt: string;
+    updatedAt: string;
+    teamSize: number;
+    tasks?: {
+        total: number;
+        completed: number;
+        running: number;
+        pending: number;
+        failed: number;
+    };
+    progressPercentage?: number;
+}
+
+/**
+ * Configuration types for Viber agents and spaces
+ */
+
+interface AgentConfig {
+    id?: string;
+    name: string;
+    description: string;
+    provider?: string;
+    model?: string;
+    llm?: {
+        provider: string;
+        model: string;
+        settings?: {
+            temperature?: number;
+            maxTokens?: number;
+            topP?: number;
+            frequencyPenalty?: number;
+            presencePenalty?: number;
+        };
+    };
+    systemPrompt?: string;
+    tools?: string[];
+    skills?: string[];
+    personality?: string;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+    promptFile?: string;
+    [key: string]: any;
+}
+
+/**
+ * Message types for Viber - Using AI SDK v6 types directly
+ */
+
+interface ViberMessage {
+    role: 'system' | 'user' | 'assistant' | 'function' | 'data' | 'tool';
+    content: any;
+    id?: string;
+    metadata?: {
+        agentName?: string;
+        timestamp?: number;
+        [key: string]: any;
+    };
+}
+type Message = ViberMessage;
+/**
+ * Get text content from a message
+ */
+declare function getTextContent(message: Message): string;
+/**
+ * Queued message with metadata
+ */
+interface QueuedMessage {
+    id: string;
+    content: string;
+    status: 'queued' | 'processing' | 'completed' | 'error';
+    timestamp: number;
+    edited?: boolean;
+    error?: string;
+    metadata?: any;
+}
+/**
+ * Queue state for UI
+ */
+interface QueueState {
+    current?: QueuedMessage;
+    queue: QueuedMessage[];
+    processing: boolean;
+}
+/**
+ * Queue listener type
+ */
+type QueueListener = (state: QueueState) => void;
+/**
+ * Enhanced Message Queue with management capabilities
+ */
+declare class MessageQueue {
+    private queue;
+    private current?;
+    private processing;
+    private listeners;
+    private nextId;
+    /**
+     * Add message to queue
+     */
+    add(content: string, metadata?: any): string;
+    /**
+     * Get next message from queue
+     */
+    next(): QueuedMessage | undefined;
+    /**
+     * Mark current message as complete
+     */
+    complete(messageId: string): void;
+    /**
+     * Mark current message as error
+     */
+    error(messageId: string, error: string): void;
+    /**
+     * Remove message from queue
+     */
+    remove(messageId: string): boolean;
+    /**
+     * Reorder queue
+     */
+    reorder(messageId: string, newIndex: number): void;
+    /**
+     * Edit queued message
+     */
+    edit(messageId: string, content: string): void;
+    /**
+     * Clear all queued messages
+     */
+    clear(): void;
+    /**
+     * Get queue state
+     */
+    getState(): QueueState;
+    /**
+     * Subscribe to queue changes
+     */
+    subscribe(listener: QueueListener): () => void;
+    /**
+     * Check if queue is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Check if processing
+     */
+    isProcessing(): boolean;
+    /**
+     * Notify listeners
+     */
+    private notify;
+}
+/**
+ * Conversation History management
+ */
+declare class ConversationHistory {
+    messages: Message[];
+    add(message: Message): void;
+    getMessages(): Message[];
+    getLastN(n: number): Message[];
+    clear(): void;
+    toModelMessages(): ModelMessage[];
+}
+
+/**
+ * Agent - Config-driven agent implementation
+ *
+ * Agents are defined entirely by configuration, not code.
+ * Each agent is instantiated from a config object that defines
+ * its role, tools, and LLM settings.
+ */
+
+interface AgentContext {
+    spaceId: string;
+    taskId?: string;
+    conversationHistory: ConversationHistory;
+    metadata?: Record<string, any>;
+}
+interface AgentResponse {
+    text: string;
+    toolCalls?: any[];
+    reasoning?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Config-driven Agent implementation
+ * No subclasses needed - behavior is entirely config-driven
+ */
+declare class Agent$1 {
+    id: string;
+    name: string;
+    description: string;
+    config: AgentConfig;
+    provider: string;
+    model: string;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+    systemPrompt?: string;
+    tools: string[];
+    skills: string[];
+    personality?: string;
+    private skillInstructions;
+    private loadedSkillTools;
+    private skillsLoaded;
+    constructor(config: AgentConfig);
+    /**
+     * Ensure skills are loaded from registry
+     */
+    private ensureSkillsLoaded;
+    /**
+     * Get the system prompt for this agent
+     */
+    protected getSystemPrompt(context?: AgentContext): string;
+    /**
+     * Get the model provider for this agent
+     */
+    getModel(context?: {
+        spaceId?: string;
+        userId?: string;
+    }): LanguageModel;
+    /**
+     * Get tools available to this agent
+     */
+    protected getTools(context?: {
+        spaceId?: string;
+    }): Promise<any>;
+    /**
+     * Prepare debug info without actually calling streamText
+     */
+    prepareDebugInfo(options: {
+        messages: ViberMessage[];
+        system?: string;
+        spaceId?: string;
+        metadata?: Record<string, any>;
+    }): Promise<{
+        systemPrompt: string;
+        tools: any;
+        model: any;
+        agentInfo: any;
+        messages: any[];
+    }>;
+    /**
+     * Stream text - works with ViberMessage[] internally
+     * Converts to ModelMessage[] only when calling AI SDK
+     */
+    streamText(options: {
+        messages: ViberMessage[];
+        system?: string;
+        spaceId?: string;
+        metadata?: Record<string, any>;
+        [key: string]: any;
+    }): Promise<any>;
+    /**
+     * Generate text - works with ViberMessage[] internally
+     * Converts to ModelMessage[] only when calling AI SDK
+     */
+    generateText(options: {
+        messages: ViberMessage[];
+        system?: string;
+        spaceId?: string;
+        metadata?: Record<string, any>;
+        [key: string]: any;
+    }): Promise<any>;
+    /**
+     * Get agent summary
+     */
+    getSummary(): Record<string, any>;
+}
+
+/**
+ * ViberAgent - The space's conversational representative
+ *
+ * X is the interface between users and their spaces. Each space has an X agent
+ * that acts as its representative. When you need to interact with a space, you
+ * talk to X. ViberAgent merges TaskExecutor and Orchestrator functionality into a
+ * single, user-friendly interface.
+ */
+
+interface ViberOptions {
+    model?: string;
+    storageRoot?: string;
+    defaultGoal?: string;
+    spaceId?: string;
+    singleAgentId?: string;
+}
+interface ViberStreamOptions {
+    messages?: any[];
+    tools?: any;
+    artifactId?: string;
+    [key: string]: any;
+}
+interface ViberAgentResponse extends AgentResponse {
+    plan?: Plan;
+    taskResults?: any[];
+    artifacts?: any[];
+    preservedSteps?: string[];
+    regeneratedSteps?: string[];
+    planChanges?: Record<string, any>;
+}
+declare class ViberAgent extends Agent$1 {
+    private space;
+    readonly spaceId: string;
+    private abortController?;
+    private singleAgentId?;
+    constructor(config: AgentConfig, space: Space$1, options?: ViberOptions);
+    /**
+     * Getter for space (needed for external access)
+     */
+    getSpace(): Space$1;
+    /**
+     * Override getSystemPrompt to include plan and artifacts context
+     */
+    getSystemPrompt(context?: AgentContext): string;
+    /**
+     * Generate text - uses new AI SDK-style signature
+     */
+    generateText(options: {
+        messages: any[];
+        system?: string;
+        [key: string]: any;
+    }): Promise<any>;
+    /**
+     * ViberAgent streamText - Orchestration Layer
+     * Responsibilities: History management, agent delegation, persistence
+     */
+    streamText(options: {
+        messages: any[];
+        system?: string;
+        spaceId?: string;
+        metadata?: Record<string, any>;
+        [key: string]: any;
+    }): Promise<any>;
+    /**
+     * Agent Mode Handler - Direct delegation with performance optimization
+     * Supports both single agent and parallel execution
+     */
+    private handleAgentMode;
+    /**
+     * Handle parallel execution of multiple agents
+     */
+    private handleParallelExecution;
+    /**
+     * Update space history with new messages
+     * Now supports per-task history
+     */
+    private updateSpaceHistory;
+    /**
+     * Optimize message context for single-agent performance
+     */
+    private optimizeContextForAgent;
+    /**
+     * Extract user prompt from messages for orchestration
+     */
+    private extractPromptFromMessages;
+    /**
+     * Handle message persistence after streaming completes
+     */
+    private handleMessagePersistence;
+    /**
+     * Save space to storage
+     */
+    private saveSpace;
+    /**
+     * Stop current operation
+     */
+    stop(): void;
+    /**
+     * Add message to queue (soft interrupt)
+     */
+    addMessage(message: string, metadata?: any): string;
+    /**
+     * Enrich context with space information
+     */
+    private enrichContext;
+    /**
+     * Create or update the space plan
+     */
+    createPlan(goal?: string): Promise<Plan>;
+    /**
+     * Adapt the plan based on new information or user feedback
+     */
+    adaptPlan(feedback: string): Promise<Plan>;
+    /**
+     * Get plan context for system prompt
+     */
+    private getPlanContext;
+    /**
+     * Get artifacts context for system prompt
+     */
+    private getArtifactsContext;
+    /**
+     * Get ViberAgent summary
+     */
+    getSummary(): Record<string, any>;
+    /**
+     * Static factory to start a new space
+     */
+    static start(goal: string, options?: ViberOptions): Promise<ViberAgent>;
+    /**
+     * Static factory to resume an existing space
+     */
+    static resume(spaceId: string, options?: ViberOptions): Promise<ViberAgent>;
+}
+
+/**
+ * Base Storage - Abstract storage interface for all Viber storage needs
+ */
+interface ArtifactInfo {
+    id: string;
+    storageKey: string;
+    originalName: string;
+    mimeType: string;
+    sizeBytes: number;
+    category?: "input" | "intermediate" | "output";
+    metadata?: Record<string, any>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface StorageAdapter {
+    readFile(path: string): Promise<Buffer>;
+    readTextFile(path: string): Promise<string>;
+    writeFile(path: string, data: Buffer | string): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    mkdir(path: string): Promise<void>;
+    readdir(path: string): Promise<string[]>;
+    stat(path: string): Promise<any>;
+    saveArtifact(spaceId: string, artifact: ArtifactInfo, buffer: Buffer): Promise<ArtifactInfo>;
+    getArtifact(spaceId: string, artifactId: string): Promise<{
+        info: ArtifactInfo;
+        buffer: Buffer;
+    } | null>;
+    getArtifactInfo(spaceId: string, artifactId: string): Promise<ArtifactInfo | null>;
+    listArtifacts(spaceId: string): Promise<ArtifactInfo[]>;
+    deleteArtifact(spaceId: string, artifactId: string): Promise<void>;
+}
+/**
+ * Base storage class with common operations
+ */
+declare class BaseStorage {
+    protected adapter: StorageAdapter;
+    protected basePath: string;
+    constructor(basePath?: string, adapter?: StorageAdapter);
+    /**
+     * Get full path relative to base
+     */
+    protected getPath(...segments: string[]): string;
+    /**
+     * Initialize storage (ensure directories exist)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Read JSON file
+     */
+    readJSON<T = any>(relativePath: string): Promise<T | null>;
+    /**
+     * Read YAML file
+     */
+    readYaml<T = any>(relativePath: string): Promise<T | null>;
+    /**
+     * Write JSON file
+     */
+    writeJSON(relativePath: string, data: any): Promise<void>;
+    /**
+     * Write YAML file
+     */
+    writeYaml(relativePath: string, data: any): Promise<void>;
+    /**
+     * Check if file exists
+     */
+    exists(relativePath: string): Promise<boolean>;
+    /**
+     * Read text file
+     */
+    readTextFile(relativePath: string): Promise<string>;
+    /**
+     * Write file (text or binary)
+     */
+    writeFile(relativePath: string, data: Buffer | string): Promise<void>;
+    /**
+     * Delete file
+     */
+    delete(relativePath: string): Promise<void>;
+    /**
+     * List files in directory
+     */
+    list(relativePath?: string): Promise<string[]>;
+    /**
+     * Create directory
+     */
+    mkdir(relativePath: string): Promise<void>;
+    /**
+     * Read binary file
+     */
+    readFile(relativePath: string): Promise<Buffer>;
+    /**
+     * Copy file from one storage to another
+     */
+    copyFileTo(relativePath: string, targetStorage: BaseStorage, targetPath: string): Promise<void>;
+    /**
+     * Get file statistics (size, timestamps, etc.)
+     */
+    getArtifactFileStats(relativePath: string): Promise<any>;
+}
+
+/**
+ * Space Storage - Handles storage operations for spaces
+ */
+
+interface StorageOptions {
+    rootPath: string;
+    spaceId: string;
+    adapter?: StorageAdapter;
+}
+declare class SpaceStorage extends BaseStorage {
+    private spaceId;
+    constructor(options: StorageOptions);
+    getSpacePath(): string;
+    getFilePath(filename: string): string;
+    saveFile(filename: string, data: any): Promise<void>;
+    saveFileBuffer(filename: string, data: Buffer): Promise<void>;
+    /**
+     * DEPRECATED: Use artifact operations below instead
+     * Save an artifact file (low-level file operation only)
+     */
+    saveArtifact(storageKey: string, buffer: Buffer, metadata: {
+        mimeType: string;
+        size: number;
+        artifactType?: string;
+    }, originalFilename?: string): Promise<void>;
+    /**
+     * Save a complete artifact (both file AND metadata)
+     */
+    saveCompleteArtifact(artifact: ArtifactInfo, buffer: Buffer): Promise<ArtifactInfo>;
+    /**
+     * Get a complete artifact (both file AND metadata)
+     */
+    getCompleteArtifact(artifactId: string): Promise<{
+        info: ArtifactInfo;
+        buffer: Buffer;
+    } | null>;
+    /**
+     * Get artifact metadata only (without loading the file)
+     */
+    getArtifactInfo(artifactId: string): Promise<ArtifactInfo | null>;
+    /**
+     * List all artifacts in this space
+     */
+    listArtifacts(): Promise<ArtifactInfo[]>;
+    /**
+     * Delete an artifact (both file AND metadata)
+     */
+    deleteCompleteArtifact(artifactId: string): Promise<void>;
+    listFiles(): Promise<string[]>;
+    createDirectory(dirname: string): Promise<void>;
+    getMetadata(): Promise<any>;
+    saveMetadata(metadata: any): Promise<void>;
+    getArtifact(filename: string): Promise<{
+        content: Buffer;
+        metadata?: any;
+    } | null>;
+    cleanup(): Promise<void>;
+}
+declare class SpaceStorageFactory {
+    private static getRootPath;
+    private static rootPath;
+    static setRootPath(rootPath: string): void;
+    static create(spaceId: string): Promise<SpaceStorage>;
+    static list(): Promise<string[]>;
+    static exists(spaceId: string): Promise<boolean>;
+    static delete(spaceId: string): Promise<void>;
+}
+
+/**
+ * Collaboration Module - Multi-Agent Collaboration Engine
+ *
+ * Provides:
+ * - Parallel agent execution
+ * - Agent-to-agent communication
+ * - Shared context management
+ * - Collaborative planning
+ */
+
+interface AgentMessage {
+    from: string;
+    to: string;
+    content: string;
+    metadata?: Record<string, any>;
+    timestamp: Date;
+}
+interface SharedContext {
+    spaceId: string;
+    data: Record<string, any>;
+    updatedAt: Date;
+    updatedBy: string;
+}
+interface ParallelTask {
+    id: string;
+    agentId: string;
+    messages: any[];
+    system?: string;
+    metadata?: Record<string, any>;
+    priority?: number;
+}
+interface ParallelExecutionResult {
+    taskId: string;
+    agentId: string;
+    result: AgentResponse;
+    error?: Error;
+    duration: number;
+}
+/**
+ * Agent Collaboration Manager
+ * Handles agent-to-agent communication and shared context
+ */
+declare class AgentCollaborationManager {
+    private space;
+    private messageQueue;
+    private sharedContext;
+    private listeners;
+    constructor(space: Space$1);
+    /**
+     * Send a message from one agent to another
+     */
+    sendMessage(from: string, to: string, content: string, metadata?: Record<string, any>): void;
+    /**
+     * Queue a message for an agent
+     */
+    private queueMessage;
+    /**
+     * Get pending messages for an agent
+     */
+    getMessages(agentId: string): AgentMessage[];
+    /**
+     * Subscribe to messages for an agent
+     */
+    subscribe(agentId: string, callback: (message: AgentMessage) => void): () => void;
+    /**
+     * Notify listeners of a new message
+     */
+    private notifyListeners;
+    /**
+     * Update shared context
+     */
+    updateContext(agentId: string, updates: Record<string, any>): void;
+    /**
+     * Get shared context
+     */
+    getContext(): SharedContext;
+    /**
+     * Get a specific value from shared context
+     */
+    getContextValue(key: string): any;
+}
+/**
+ * Parallel Execution Engine
+ * Executes multiple agent tasks in parallel
+ */
+declare class ParallelExecutionEngine {
+    private space;
+    private maxConcurrency;
+    private activeTasks;
+    constructor(space: Space$1, maxConcurrency?: number);
+    /**
+     * Execute multiple tasks in parallel
+     */
+    executeParallel(tasks: ParallelTask[]): Promise<ParallelExecutionResult[]>;
+    /**
+     * Execute a single task
+     */
+    private executeTask;
+    /**
+     * Cancel a running task
+     */
+    cancelTask(taskId: string): void;
+    /**
+     * Get active task count
+     */
+    getActiveTaskCount(): number;
+}
+/**
+ * Collaborative Planner
+ * Helps agents plan together
+ */
+declare class CollaborativePlanner {
+    private space;
+    private collaborationManager;
+    constructor(space: Space$1, collaborationManager: AgentCollaborationManager);
+    /**
+     * Create a collaborative plan with multiple agents
+     */
+    createCollaborativePlan(goal: string, agentIds: string[]): Promise<{
+        plan: any;
+        agentAssignments: Map<string, string[]>;
+    }>;
+    /**
+     * Merge multiple agent plans into one
+     */
+    private mergePlans;
+    /**
+     * Assign tasks to agents
+     */
+    private assignTasks;
+}
+
+/**
+ * Space - The top-level container for Viber work (formerly Space)
+ *
+ * A Space represents a project context that contains multiple tasks.
+ * Each space is managed by an XAgent that serves as its orchestrator.
+ *
+ * Key concepts:
+ * - Space: Project container with shared configuration
+ * - Task: Individual conversation threads within a space
+ * - Each task has its own conversation history and artifacts
+ */
+
+interface SpaceTask {
+    id: string;
+    spaceId: string;
+    title: string;
+    history: ConversationHistory;
+    artifactIds: string[];
+    status: "active" | "completed" | "archived";
+    createdAt: Date;
+    updatedAt: Date;
+}
+declare class Space$1 {
+    spaceId: string;
+    userId?: string;
+    config: SpaceConfig;
+    history: ConversationHistory;
+    tasks: Map<string, SpaceTask>;
+    messageQueue: MessageQueue;
+    agents: Map<string, Agent$1>;
+    storage: SpaceStorage;
+    goal: string;
+    name: string;
+    viberAgent?: ViberAgent;
+    createdAt: Date;
+    updatedAt: Date;
+    plan?: Plan;
+    artifacts?: any[];
+    collaborationManager?: AgentCollaborationManager;
+    parallelEngine?: ParallelExecutionEngine;
+    collaborativePlanner?: CollaborativePlanner;
+    constructor({ spaceId, userId, config, history, messageQueue, agents, storage, goal, name, viberAgent, }: {
+        spaceId: string;
+        userId?: string;
+        config: SpaceConfig;
+        history: ConversationHistory;
+        messageQueue: MessageQueue;
+        agents: Map<string, Agent$1>;
+        storage: SpaceStorage;
+        goal: string;
+        name?: string;
+        viberAgent?: ViberAgent;
+    });
+    /**
+     * Get or create a task within this space
+     */
+    getOrCreateTask(taskId: string, title?: string): SpaceTask;
+    /**
+     * Get task by ID
+     */
+    getTask(taskId: string): SpaceTask | undefined;
+    /**
+     * Get all tasks in this space
+     */
+    getAllTasks(): SpaceTask[];
+    /**
+     * Update space task status (for conversation tasks, not Plan tasks)
+     */
+    updateSpaceTaskStatus(taskId: string, status: "active" | "completed" | "archived"): boolean;
+    getAgent(name: string): Agent$1 | undefined;
+    registerAgent(name: string, agent: Agent$1): void;
+    complete(): void;
+    getContext(): Record<string, any>;
+    createPlan(plan: Plan): Promise<void>;
+    updatePlan(plan: Plan): Promise<void>;
+    setName(name: string): Promise<void>;
+    getNextTask(): Promise<Task$1 | undefined>;
+    getParallelTasks(maxTasks?: number): Promise<Task$1[]>;
+    updateTaskStatus(taskId: string, status: TaskStatus): Promise<boolean>;
+    assignTask(taskId: string, agentName: string): Promise<boolean>;
+    isPlanComplete(): boolean;
+    hasFailedTasks(): boolean;
+    persistState(): Promise<void>;
+    loadState(): Promise<boolean>;
+    loadPlan(): Promise<Plan | undefined>;
+    getState(): SpaceState;
+}
+/**
+ * Start a new space
+ */
+declare function startSpace({ goal, spaceId, userId, spaceRoot, name, model, }: {
+    goal: string;
+    spaceId?: string;
+    userId?: string;
+    spaceRoot?: string;
+    name?: string;
+    model?: string;
+}): Promise<Space$1>;
+
+/**
+ * AI Provider Management
+ * Handles initialization and configuration of different AI providers
+ *
+ * Philosophy: Keep it simple - agents specify their provider and model explicitly.
+ *
+ * To add a new provider (e.g., Google, Mistral, Cohere):
+ * 1. Install: `pnpm add @ai-sdk/google`
+ * 2. Import: `import { createGoogleGenerativeAI } from "@ai-sdk/google";`
+ * 3. Add case: `case "google": return createGoogleGenerativeAI({...})`
+ * 4. Add environment variable handling
+ */
+type ModelProvider$1 = string;
+interface ModelConfig$1 {
+    provider: ModelProvider$1;
+    modelName: string;
+    apiKey?: string;
+    baseURL?: string;
+    spaceId?: string;
+    userId?: string;
+    storageRoot?: string;
+    teamConfig?: string;
+    defaultGoal?: string;
+}
+/**
+ * Get the appropriate AI provider instance
+ */
+declare function getModelProvider(config: ModelConfig$1): _ai_sdk_openai.OpenAIProvider | _ai_sdk_deepseek.DeepSeekProvider | _openrouter_ai_sdk_provider.OpenRouterProvider;
+/**
+ * Parse model string to extract provider and model name
+ * Examples: "gpt-4o" -> { provider: "openai", modelName: "gpt-4o" }
+ */
+declare function parseModelString(model: string): ModelConfig$1;
+
+/**
+ * Tool System for Viber
+ *
+ * Coordinates between custom tools and MCP tools.
+ * Knows nothing about specific tool implementations.
+ */
+
+interface CoreTool {
+    description: string;
+    inputSchema: z.ZodSchema | any;
+    execute: (args: any, context?: any) => Promise<any>;
+}
+/**
+ * Build a tool map for streamText from an array of tool IDs
+ * Delegates to appropriate providers without knowing their internals
+ */
+declare function buildToolMap(toolIds: string[], context?: {
+    spaceId?: string;
+}): Promise<Record<string, CoreTool>>;
+/**
+ * Check if an object is a valid tool
+ */
+declare function isValidTool(obj: any): boolean;
+/**
+ * Clear MCP cache (useful for testing)
+ */
+declare function clearToolCache(): void;
+
+/**
+ * Data types for Viber entities
+ * Moved from lib/data/types.ts to make Viber the single source of truth
+ */
+interface Agent {
+    id: string;
+    userId?: string;
+    name: string;
+    description: string;
+    category?: string;
+    icon?: string;
+    logoUrl?: string;
+    tags?: string[];
+    systemPrompt?: string;
+    llm?: {
+        provider: string;
+        model: string;
+        settings?: {
+            temperature?: number;
+            maxTokens?: number;
+            topP?: number;
+            frequencyPenalty?: number;
+            presencePenalty?: number;
+        };
+    };
+    tools?: string[];
+    author?: string;
+    version?: string;
+    usageExamples?: string[];
+    requirements?: string[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface Tool {
+    id: string;
+    userId?: string;
+    name: string;
+    description: string;
+    type: "builtin" | "mcp" | "custom";
+    vendor?: string;
+    category?: string;
+    icon?: string;
+    logoUrl?: string;
+    config?: Record<string, any>;
+    configSchema?: any[];
+    features?: string[];
+    tags?: string[];
+    status?: "active" | "inactive" | "deprecated";
+    ready?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface Space {
+    id: string;
+    userId?: string;
+    name: string;
+    description?: string;
+    goal?: string;
+    config?: Record<string, any>;
+    teamConfig?: any;
+    activeArtifactId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface Artifact {
+    id: string;
+    spaceId?: string;
+    taskId?: string;
+    userId?: string;
+    category?: "input" | "intermediate" | "output";
+    storageKey: string;
+    originalName: string;
+    mimeType: string;
+    sizeBytes: number;
+    metadata?: Record<string, any>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface Conversation {
+    id: string;
+    spaceId?: string;
+    userId?: string;
+    title?: string;
+    messages?: any[];
+    metadata?: Record<string, any>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface Task {
+    id: string;
+    spaceId?: string;
+    userId?: string;
+    title?: string;
+    description?: string;
+    status?: "pending" | "active" | "completed" | "failed";
+    result?: any;
+    metadata?: Record<string, any>;
+    model?: string;
+    mode?: string;
+    systemMessage?: string;
+    messages?: any[];
+    supervision?: any;
+    context?: any;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface ModelConfig {
+    id: string;
+    name: string;
+}
+interface ModelProvider {
+    id: string;
+    name: string;
+    provider: string;
+    enabled?: boolean;
+    baseUrl?: string;
+    apiKey?: string;
+    models?: string[] | ModelConfig[];
+    config?: Record<string, any>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface Datasource {
+    id: string;
+    name: string;
+    type: string;
+    config?: Record<string, any>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+
+/**
+ * DataAdapter interface for accessing agents, tools, spaces, etc.
+ * This is an internal interface used by ViberDataManager.
+ * External code should use ViberDataManager, not DataAdapter directly.
+ */
+
+/**
+ * Internal adapter interface for data persistence
+ * Implementations handle local files or remote database/API
+ */
+interface DataAdapter {
+    getAgents(): Promise<Agent[]>;
+    getAgent(id: string): Promise<Agent | null>;
+    saveAgent(agent: Agent): Promise<Agent>;
+    deleteAgent(id: string): Promise<void>;
+    cloneAgent(id: string): Promise<Agent>;
+    getTools(): Promise<Tool[]>;
+    getTool(id: string): Promise<Tool | null>;
+    saveTool(tool: Tool): Promise<Tool>;
+    deleteTool(id: string): Promise<void>;
+    cloneTool(id: string): Promise<Tool>;
+    getSpaces(): Promise<Space[]>;
+    getSpace(id: string): Promise<Space | null>;
+    saveSpace(space: Space): Promise<Space>;
+    deleteSpace(id: string): Promise<void>;
+    getArtifacts(spaceId: string): Promise<Artifact[]>;
+    getArtifact(id: string): Promise<Artifact | null>;
+    saveArtifact(artifact: Artifact): Promise<Artifact>;
+    deleteArtifact(id: string): Promise<void>;
+    getArtifactsBySpace(spaceId: string): Promise<Artifact[]>;
+    getArtifactsByTask(taskId: string): Promise<Artifact[]>;
+    getArtifactsByCategory(spaceOrTaskId: string, category: "input" | "intermediate" | "output", isTask?: boolean): Promise<Artifact[]>;
+    getTasks(spaceId: string): Promise<Task[]>;
+    getTask(id: string): Promise<Task | null>;
+    saveTask(task: Task): Promise<Task>;
+    deleteTask(id: string): Promise<void>;
+    getConversations(spaceId: string): Promise<Conversation[]>;
+    getConversation(id: string): Promise<Conversation | null>;
+    saveConversation(conversation: Conversation): Promise<Conversation>;
+    deleteConversation(id: string): Promise<void>;
+    getModelProviders(): Promise<ModelProvider[]>;
+    getModelProvider(id: string): Promise<ModelProvider | null>;
+    saveModelProvider(provider: ModelProvider): Promise<ModelProvider>;
+    deleteModelProvider(id: string): Promise<void>;
+    getDatasources(): Promise<Datasource[]>;
+    getDatasource(id: string): Promise<Datasource | null>;
+    saveDatasource(datasource: Datasource): Promise<Datasource>;
+    deleteDatasource(id: string): Promise<void>;
+}
+
+/**
+ * ViberDataManager - Unified Data Access Layer
+ *
+ * This is the single source of truth for all Viber data operations.
+ * It unifies DataAdapter (metadata) and SpaceStorage (files) into one interface.
+ *
+ * Key features:
+ * - Unified query interface for spaces, artifacts, tasks, agents, tools
+ * - Automatic caching
+ * - Real-time subscriptions (when supported)
+ * - Optimistic updates
+ */
+
+interface SpaceFilters {
+    userId?: string;
+    name?: string;
+    createdAfter?: Date;
+    createdBefore?: Date;
+}
+interface ArtifactFilters {
+    spaceId?: string;
+    taskId?: string;
+    category?: "input" | "intermediate" | "output";
+    mimeType?: string;
+}
+interface TaskFilters {
+    spaceId: string;
+    status?: "active" | "completed" | "archived";
+    createdAfter?: Date;
+}
+type Unsubscribe = () => void;
+type SubscriptionCallback<T> = (data: T) => void;
+/**
+ * ViberDataManager - Central data access layer
+ */
+declare class ViberDataManager {
+    private dataAdapter;
+    private cache;
+    private subscriptions;
+    private cacheTTL;
+    constructor(dataAdapter?: DataAdapter);
+    /**
+     * Create a server-side instance (uses direct database access)
+     * Uses dynamic import to avoid bundling server code in client
+     *
+     * NOTE: This should only be called from server-side code (API routes, server components)
+     */
+    static createServer(): Promise<ViberDataManager>;
+    /**
+     * Create a server-side instance synchronously (for use in server contexts)
+     * This uses require() to avoid bundling in client code
+     */
+    static createServerSync(): ViberDataManager;
+    /**
+     * Create a client-side instance (uses API calls)
+     * @deprecated Client-side direct usage is deprecated. Use server actions instead.
+     */
+    static createClient(): ViberDataManager;
+    private getCacheKey;
+    private getCached;
+    private setCache;
+    private invalidateCache;
+    private notifySubscribers;
+    /**
+     * Get a single space by ID
+     */
+    getSpace(spaceId: string): Promise<Space | null>;
+    /**
+     * List all spaces with optional filters
+     */
+    listSpaces(filters?: SpaceFilters): Promise<Space[]>;
+    /**
+     * Create a new space
+     */
+    createSpace(space: Partial<Space>): Promise<Space>;
+    /**
+     * Update a space
+     */
+    updateSpace(spaceId: string, updates: Partial<Space>): Promise<Space>;
+    /**
+     * Delete a space
+     */
+    deleteSpace(spaceId: string): Promise<void>;
+    /**
+     * Subscribe to space changes
+     */
+    subscribeToSpace(spaceId: string, callback: SubscriptionCallback<Space | null>): Unsubscribe;
+    /**
+     * Subscribe to all spaces
+     */
+    subscribeToSpaces(callback: SubscriptionCallback<Space[]>): Unsubscribe;
+    /**
+     * Get artifacts for a space
+     */
+    getArtifacts(spaceId: string, filters?: ArtifactFilters): Promise<Artifact[]>;
+    /**
+     * Get a single artifact by ID
+     */
+    getArtifact(artifactId: string): Promise<Artifact | null>;
+    /**
+     * Create an artifact (metadata only - file upload handled separately)
+     */
+    createArtifact(spaceId: string, artifact: Partial<Artifact>): Promise<Artifact>;
+    /**
+     * Update an artifact
+     */
+    updateArtifact(artifactId: string, updates: Partial<Artifact>): Promise<Artifact>;
+    /**
+     * Delete an artifact
+     */
+    deleteArtifact(artifactId: string, spaceId: string): Promise<void>;
+    /**
+     * Subscribe to artifacts for a space
+     */
+    subscribeToArtifacts(spaceId: string, callback: SubscriptionCallback<Artifact[]>): Unsubscribe;
+    /**
+     * Get tasks for a space
+     */
+    getTasks(spaceId: string, filters?: TaskFilters): Promise<Task[]>;
+    /**
+     * Get a single task by ID
+     */
+    getTask(taskId: string): Promise<Task | null>;
+    /**
+     * Create a new task
+     */
+    createTask(spaceId: string, task: Partial<Task>): Promise<Task>;
+    /**
+     * Update a task
+     */
+    updateTask(taskId: string, updates: Partial<Task>): Promise<Task>;
+    /**
+     * Delete a task
+     */
+    deleteTask(taskId: string, spaceId: string): Promise<void>;
+    /**
+     * Subscribe to tasks for a space
+     */
+    subscribeToTasks(spaceId: string, callback: SubscriptionCallback<Task[]>): Unsubscribe;
+    /**
+     * Get all agents
+     */
+    getAgents(): Promise<Agent[]>;
+    /**
+     * Get a single agent by ID
+     */
+    getAgent(agentId: string): Promise<Agent | null>;
+    /**
+     * Get all tools
+     */
+    getTools(): Promise<Tool[]>;
+    /**
+     * Get a single tool by ID
+     */
+    getTool(toolId: string): Promise<Tool | null>;
+    /**
+     * Get SpaceStorage instance for a space
+     */
+    getSpaceStorage(spaceId: string): Promise<SpaceStorage>;
+    /**
+     * Upload an artifact file
+     */
+    uploadArtifactFile(spaceId: string, artifactId: string, file: File | Blob, filename: string): Promise<string>;
+    /**
+     * Download an artifact file
+     */
+    downloadArtifactFile(spaceId: string, storageKey: string): Promise<Blob>;
+    /**
+     * Delete an artifact file
+     */
+    deleteArtifactFile(spaceId: string, storageKey: string): Promise<void>;
+}
+declare function getViberDataManager(): ViberDataManager;
+/**
+ * Get server-side ViberDataManager (for API routes and server components)
+ * This uses direct database access, not API calls
+ *
+ * NOTE: This function can only be called from server-side code
+ */
+declare function getViberDataManagerServer(): ViberDataManager;
+
+interface ViberState {
+    spaces: Map<string, Space>;
+    currentSpaceId: string | null;
+    artifacts: Map<string, Artifact[]>;
+    tasks: Map<string, Task[]>;
+    agents: Agent[];
+    tools: Tool[];
+    loading: {
+        spaces: boolean;
+        artifacts: Record<string, boolean>;
+        tasks: Record<string, boolean>;
+        agents: boolean;
+        tools: boolean;
+    };
+    errors: {
+        spaces: Error | null;
+        artifacts: Record<string, Error | null>;
+        tasks: Record<string, Error | null>;
+        agents: Error | null;
+        tools: Error | null;
+    };
+    setSpaces: (spaces: Space[]) => void;
+    setSpace: (space: Space) => void;
+    removeSpace: (spaceId: string) => void;
+    setCurrentSpaceId: (spaceId: string | null) => void;
+    setArtifacts: (spaceId: string, artifacts: Artifact[]) => void;
+    addArtifact: (spaceId: string, artifact: Artifact) => void;
+    updateArtifact: (spaceId: string, artifactId: string, updates: Partial<Artifact>) => void;
+    removeArtifact: (spaceId: string, artifactId: string) => void;
+    setTasks: (spaceId: string, tasks: Task[]) => void;
+    addTask: (spaceId: string, task: Task) => void;
+    updateTask: (spaceId: string, taskId: string, updates: Partial<Task>) => void;
+    removeTask: (spaceId: string, taskId: string) => void;
+    setAgents: (agents: Agent[]) => void;
+    setTools: (tools: Tool[]) => void;
+    setLoading: (key: string, value: boolean) => void;
+    setError: (key: string, error: Error | null) => void;
+    syncSpaces: () => Promise<void>;
+    syncArtifacts: (spaceId: string) => Promise<void>;
+    syncTasks: (spaceId: string) => Promise<void>;
+    syncAgents: () => Promise<void>;
+    syncTools: () => Promise<void>;
+}
+declare const useViberStore: zustand.UseBoundStore<Omit<zustand.StoreApi<ViberState>, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: ViberState, previousSelectedState: ViberState) => void): () => void;
+        <U>(selector: (state: ViberState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}>;
+declare const useViberSpaces: () => Space[];
+declare const useViberCurrentSpace: () => Space | null;
+declare const useViberArtifacts: (spaceId: string | null | undefined) => Artifact[];
+declare const useViberTasks: (spaceId: string | null | undefined) => Task[];
+
+/**
+ * ViberController - Daemon controller for outbound connection to command center
+ *
+ * A Viber is a local agent daemon that connects OUTBOUND to a central command center
+ * (Supen). This eliminates the need for public IPs or port forwarding.
+ *
+ * Features:
+ * - Persistent WebSocket connection to command center
+ * - Auto-reconnection on disconnect
+ * - Heartbeat/health monitoring
+ * - Task execution and event streaming
+ */
+
+interface ViberControllerConfig {
+    /** WebSocket URL to connect to (e.g., wss://supen.app/vibers/ws) */
+    serverUrl: string;
+    /** Authentication token */
+    token: string;
+    /** Unique identifier for this viber */
+    viberId: string;
+    /** Human-readable name for this viber */
+    viberName?: string;
+    /** Milliseconds between reconnection attempts */
+    reconnectInterval?: number;
+    /** Milliseconds between heartbeat messages */
+    heartbeatInterval?: number;
+    /** Enable desktop control tools */
+    enableDesktop?: boolean;
+}
+interface ViberSkillInfo {
+    id: string;
+    name: string;
+    description: string;
+}
+interface ViberInfo {
+    id: string;
+    name: string;
+    version: string;
+    platform: string;
+    capabilities: string[];
+    runningTasks: string[];
+    /** Skills available on this viber (from SKILL.md) */
+    skills?: ViberSkillInfo[];
+}
+interface ViberStatus {
+    platform: string;
+    uptime: number;
+    memory: NodeJS.MemoryUsage;
+    runningTasks: number;
+}
+type ControllerServerMessage = {
+    type: "task:submit";
+    taskId: string;
+    goal: string;
+    options?: ViberOptions;
+    messages?: {
+        role: string;
+        content: string;
+    }[];
+} | {
+    type: "task:stop";
+    taskId: string;
+} | {
+    type: "task:message";
+    taskId: string;
+    message: string;
+} | {
+    type: "ping";
+} | {
+    type: "config:update";
+    config: Partial<ViberControllerConfig>;
+} | {
+    type: "terminal:list";
+} | {
+    type: "terminal:attach";
+    target: string;
+} | {
+    type: "terminal:detach";
+    target: string;
+} | {
+    type: "terminal:input";
+    target: string;
+    keys: string;
+} | {
+    type: "terminal:resize";
+    target: string;
+    cols: number;
+    rows: number;
+};
+type ControllerClientMessage = {
+    type: "connected";
+    viber: ViberInfo;
+} | {
+    type: "task:started";
+    taskId: string;
+    spaceId: string;
+} | {
+    type: "task:progress";
+    taskId: string;
+    event: any;
+} | {
+    type: "task:completed";
+    taskId: string;
+    result: any;
+} | {
+    type: "task:error";
+    taskId: string;
+    error: string;
+} | {
+    type: "heartbeat";
+    status: ViberStatus;
+} | {
+    type: "pong";
+} | {
+    type: "terminal:list";
+    sessions: any[];
+    panes: any[];
+} | {
+    type: "terminal:attached";
+    target: string;
+    ok: boolean;
+    error?: string;
+} | {
+    type: "terminal:detached";
+    target: string;
+} | {
+    type: "terminal:output";
+    target: string;
+    data: string;
+} | {
+    type: "terminal:resized";
+    target: string;
+    ok: boolean;
+};
+declare class ViberController extends EventEmitter {
+    private config;
+    private ws;
+    private reconnectTimer;
+    private heartbeatTimer;
+    /** taskId -> AbortController for stop (daemon = thin runtime, no Space/agent instance) */
+    private runningTasks;
+    private isConnected;
+    private shouldReconnect;
+    /** Terminal manager for streaming tmux panes */
+    private terminalManager;
+    constructor(config: ViberControllerConfig);
+    /**
+     * Start the viber daemon
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the viber daemon
+     */
+    stop(): Promise<void>;
+    /**
+     * Get current connection status
+     */
+    getStatus(): {
+        connected: boolean;
+        runningTasks: number;
+    };
+    private connect;
+    private onConnected;
+    private onDisconnected;
+    private onError;
+    private onMessage;
+    private handleTaskSubmit;
+    private handleTaskStop;
+    private handleTaskMessage;
+    private handleTerminalList;
+    private handleTerminalAttach;
+    private handleTerminalDetach;
+    private handleTerminalInput;
+    private handleTerminalResize;
+    private send;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private scheduleReconnect;
+}
+
+/**
+ * Daemon runtime - thin clawdbot-alike assistant path
+ *
+ * No Space, no DataAdapter, no Storage. Loads a single agent config from file
+ * and runs streamText. Viber Board owns persistence and context; daemon only
+ * orchestrates local skills and the LLM.
+ */
+
+interface DaemonRunTaskOptions {
+    model?: string;
+    singleAgentId?: string;
+    agentConfig?: AgentConfig;
+    signal?: AbortSignal;
+}
+/**
+ * Load agent config from file (no DataAdapter).
+ * Tries built-in defaults then ~/.openviber/agents/{id}.yaml
+ */
+declare function loadAgentConfig(agentId: string): Promise<AgentConfig | null>;
+/**
+ * Run a single task: one agent, no Space, no storage.
+ * Returns stream result and agent for summary.
+ */
+declare function runTask(goal: string, options: DaemonRunTaskOptions & {
+    taskId: string;
+}, messages?: {
+    role: string;
+    content: string;
+}[]): Promise<{
+    streamResult: Awaited<ReturnType<Agent$1["streamText"]>>;
+    agent: Agent$1;
+}>;
+
+export { Agent$1 as Agent, AgentCollaborationManager, type AgentConfig, type AgentContext, type AgentMessage, type AgentResponse, type ArtifactFilters, type ArtifactInfo, BaseStorage, CollaborativePlanner, type ControllerClientMessage, type ControllerServerMessage, ConversationHistory, type CoreTool, type DaemonRunTaskOptions, type Message, MessageQueue, type ModelConfig$2 as ModelConfig, type ModelProvider$1 as ModelProvider, ParallelExecutionEngine, type ParallelExecutionResult, type ParallelTask, Plan, type PlanSummary, type QueueListener, type QueueState, type QueuedMessage, type SharedContext, Space$1 as Space, type SpaceConfig, type SpaceFilters, type SpaceModel, type SpaceState, SpaceStorage, SpaceStorageFactory, type SpaceTask, type StorageAdapter, type StorageConfig, type StorageOptions, type StreamChunk, type SubscriptionCallback, Task$1 as Task, type TaskDependency, type TaskFilters, TaskStatus, type TaskStep, type Unsubscribe, ViberAgent, type ViberAgentResponse, type ViberConfig, ViberController, type ViberControllerConfig, ViberDataManager, type ViberError, type ViberInfo, type ViberMessage, type ViberOptions, type ViberSkillInfo, type ViberStatus, type ViberStreamOptions, buildToolMap, clearToolCache, getModelProvider, getTextContent, getViberDataManager, getViberDataManagerServer, isValidTool, loadAgentConfig, parseModelString, runTask, startSpace, useViberArtifacts, useViberCurrentSpace, useViberSpaces, useViberStore, useViberTasks };