openviber 0.5.0 → 0.5.2

package/dist/index.d.ts

@@ -1,11 +1,9 @@
 import { ModelMessage, LanguageModel } from 'ai';
 export { Output, ToolLoopAgent, generateText, stepCountIs, streamText } from 'ai';
+import { z } from 'zod';
 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
@@ -30,7 +28,7 @@ interface TaskDependency {
     taskId: string;
     type: "required" | "optional";
 }
-declare class Task$1 {
+declare class Task {
     id: string;
     title: string;
     description: string;
@@ -74,7 +72,7 @@ declare class Task$1 {
     }): boolean;
     private calculateDuration;
     toJSON(): any;
-    static fromJSON(data: any): Task$1;
+    static fromJSON(data: any): Task;
 }
 
 /**
@@ -91,22 +89,22 @@ interface PlanSummary {
     progressPercentage: number;
 }
 declare class Plan {
-    tasks: Task$1[];
+    tasks: Task[];
     goal: string;
     createdAt: Date;
     updatedAt: Date;
     constructor({ tasks, goal }: {
-        tasks?: Task$1[];
+        tasks?: Task[];
         goal: string;
     });
-    addTask(task: Task$1): void;
+    addTask(task: Task): void;
     removeTask(taskId: string): boolean;
-    getTaskById(taskId: string): Task$1 | undefined;
+    getTaskById(taskId: string): Task | 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[];
+    getNextActionableTask(): Task | undefined;
+    getAllActionableTasks(maxTasks?: number): Task[];
+    getTasksByStatus(status: TaskStatus): Task[];
+    getTasksByAssignee(assignee: string): Task[];
     isComplete(): boolean;
     hasFailedTasks(): boolean;
     hasBlockedTasks(): boolean;
@@ -133,24 +131,12 @@ interface StreamChunk {
     };
     error?: ViberError;
 }
-interface ModelConfig$2 {
+interface ModelConfig$1 {
     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
  */
@@ -199,12 +185,137 @@ interface SpaceState {
     };
     progressPercentage?: number;
 }
-
+interface AgentData {
+    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;
+    isCustom?: boolean;
+}
+interface ToolData {
+    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 SpaceData {
+    id: string;
+    userId?: string;
+    name: string;
+    description?: string;
+    goal?: string;
+    config?: Record<string, any>;
+    teamConfig?: any;
+    activeArtifactId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface ArtifactData {
+    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 ConversationData {
+    id: string;
+    spaceId?: string;
+    userId?: string;
+    title?: string;
+    messages?: any[];
+    metadata?: Record<string, any>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface TaskData {
+    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 ProviderModelConfig {
+    id: string;
+    name: string;
+}
+interface ModelProviderData {
+    id: string;
+    name: string;
+    provider: string;
+    enabled?: boolean;
+    baseUrl?: string;
+    apiKey?: string;
+    models?: string[] | ProviderModelConfig[];
+    config?: Record<string, any>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface DatasourceData {
+    id: string;
+    name: string;
+    type: string;
+    config?: Record<string, any>;
+    createdAt?: string;
+    updatedAt?: string;
+}
 /**
- * Configuration types for Viber agents and spaces
+ * Configuration for creating/initializing a Viber
  */
-
-interface AgentConfig {
+interface ViberConfig {
     id?: string;
     name: string;
     description: string;
@@ -222,15 +333,24 @@ interface AgentConfig {
         };
     };
     systemPrompt?: string;
+    promptFile?: string;
     tools?: string[];
     skills?: string[];
+    /** Primary coding CLI skill id (from settings); agent prefers it for coding tasks when set. */
+    primaryCodingCli?: string | null;
     personality?: string;
     temperature?: number;
     maxTokens?: number;
+    /** Maximum number of multi-step tool-call rounds (default: 10) */
+    maxSteps?: number;
     topP?: number;
     frequencyPenalty?: number;
     presencePenalty?: number;
-    promptFile?: string;
+    metadata?: Record<string, any>;
+    mode?: "always_ask" | "agent_decides" | "always_execute" | "always-ask" | "agent-decides" | "viber_decides" | "viber-decides" | "always-execute";
+    workingMode?: "always_ask" | "agent_decides" | "always_execute" | "always-ask" | "agent-decides" | "viber_decides" | "viber-decides" | "always-execute";
+    requireApproval?: string[];
+    require_approval?: string[];
     [key: string]: any;
 }
 
@@ -351,6 +471,55 @@ declare class ConversationHistory {
     toModelMessages(): ModelMessage[];
 }
 
+/**
+ * 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>;
+}
+/** Progress callback for tools to emit intermediate updates */
+type ToolProgressCallback = (event: {
+    kind: string;
+    phase?: string;
+    message?: string;
+    data?: any;
+}) => void;
+/** Context passed through to tool execution */
+interface ToolContext {
+    spaceId?: string;
+    oauthTokens?: {
+        google?: {
+            accessToken: string;
+            refreshToken?: string | null;
+        };
+        [provider: string]: {
+            accessToken: string;
+            refreshToken?: string | null;
+        } | undefined;
+    };
+    /** Optional progress callback for tools to emit intermediate updates */
+    onProgress?: ToolProgressCallback;
+}
+/**
+ * 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?: ToolContext): 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;
+
 /**
  * Agent - Config-driven agent implementation
  *
@@ -375,11 +544,11 @@ interface AgentResponse {
  * Config-driven Agent implementation
  * No subclasses needed - behavior is entirely config-driven
  */
-declare class Agent$1 {
+declare class Agent {
     id: string;
     name: string;
     description: string;
-    config: AgentConfig;
+    config: ViberConfig;
     provider: string;
     model: string;
     temperature?: number;
@@ -391,12 +560,22 @@ declare class Agent$1 {
     tools: string[];
     skills: string[];
     personality?: string;
+    maxSteps: number;
+    mode: "always_ask" | "agent_decides" | "always_execute";
+    requireApproval: Set<string>;
     private skillInstructions;
     private loadedSkillTools;
     private skillsLoaded;
-    constructor(config: AgentConfig);
+    proxyFetch?: typeof fetch;
+    constructor(config: ViberConfig);
     /**
-     * Ensure skills are loaded from registry
+     * Ensure skills are loaded from registry.
+     *
+     * Skills and tools are separate concepts (per Agent Skills spec):
+     * - Skills (SKILL.md) provide instructions — injected into the system prompt
+     *   for progressive discovery. The agent learns WHEN and HOW to do things.
+     * - Tools (CoreTool) provide executable capabilities — registered in the
+     *   ToolRegistry and loaded by namespace.
      */
     private ensureSkillsLoaded;
     /**
@@ -411,10 +590,14 @@ declare class Agent$1 {
         userId?: string;
     }): LanguageModel;
     /**
-     * Get tools available to this agent
+     * Get tools available to this agent.
+     *
+     * Converts CoreTool format ({inputSchema}) to AI SDK format ({parameters})
+     * so that streamText() recognizes and exposes the tools to the model.
      */
     protected getTools(context?: {
         spaceId?: string;
+        metadata?: Record<string, unknown>;
     }): Promise<any>;
     /**
      * Prepare debug info without actually calling streamText
@@ -458,15 +641,27 @@ declare class Agent$1 {
      */
     getSummary(): Record<string, any>;
 }
-
+type WorkingMode = "always_ask" | "agent_decides" | "always_execute";
 /**
- * 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.
+ * Resolve the configured working mode from supported config keys.
+ */
+declare function resolveWorkingMode(config: ViberConfig): WorkingMode;
+/**
+ * Resolve tools that require explicit approval in agent_decides mode.
+ */
+declare function resolveRequireApprovalTools(config: ViberConfig): Set<string>;
+/**
+ * Check whether the current request metadata includes approval for a tool.
+ */
+declare function hasToolApproval(metadata: Record<string, unknown> | undefined, toolName: string): boolean;
+/**
+ * Wrap tools with working-mode approval checks.
  */
+declare function applyWorkingModeToTools(tools: Record<string, CoreTool> | undefined, options: {
+    mode: WorkingMode;
+    requireApproval: Set<string>;
+    metadata?: Record<string, unknown>;
+}): Record<string, CoreTool> | undefined;
 
 interface ViberOptions {
     model?: string;
@@ -474,6 +669,11 @@ interface ViberOptions {
     defaultGoal?: string;
     spaceId?: string;
     singleAgentId?: string;
+    /** User settings from Supabase (primary coding CLI etc.); node uses and caches locally */
+    settings?: {
+        primaryCodingCli?: string;
+        channelIds?: string[];
+    };
 }
 interface ViberStreamOptions {
     messages?: any[];
@@ -489,16 +689,16 @@ interface ViberAgentResponse extends AgentResponse {
     regeneratedSteps?: string[];
     planChanges?: Record<string, any>;
 }
-declare class ViberAgent extends Agent$1 {
+declare class ViberAgent extends Agent {
     private space;
     readonly spaceId: string;
     private abortController?;
     private singleAgentId?;
-    constructor(config: AgentConfig, space: Space$1, options?: ViberOptions);
+    constructor(config: ViberConfig, space: Space, options?: ViberOptions);
     /**
      * Getter for space (needed for external access)
      */
-    getSpace(): Space$1;
+    getSpace(): Space;
     /**
      * Override getSystemPrompt to include plan and artifacts context
      */
@@ -550,6 +750,9 @@ declare class ViberAgent extends Agent$1 {
     private handleMessagePersistence;
     /**
      * Save space to storage
+     *
+     * @deprecated Space data is now persisted through the data adapter (spaces table).
+     * This method is kept for interface compatibility but performs no action.
      */
     private saveSpace;
     /**
@@ -594,175 +797,6 @@ declare class ViberAgent extends Agent$1 {
     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
  *
@@ -810,7 +844,7 @@ declare class AgentCollaborationManager {
     private messageQueue;
     private sharedContext;
     private listeners;
-    constructor(space: Space$1);
+    constructor(space: Space);
     /**
      * Send a message from one agent to another
      */
@@ -852,7 +886,7 @@ declare class ParallelExecutionEngine {
     private space;
     private maxConcurrency;
     private activeTasks;
-    constructor(space: Space$1, maxConcurrency?: number);
+    constructor(space: Space, maxConcurrency?: number);
     /**
      * Execute multiple tasks in parallel
      */
@@ -877,7 +911,7 @@ declare class ParallelExecutionEngine {
 declare class CollaborativePlanner {
     private space;
     private collaborationManager;
-    constructor(space: Space$1, collaborationManager: AgentCollaborationManager);
+    constructor(space: Space, collaborationManager: AgentCollaborationManager);
     /**
      * Create a collaborative plan with multiple agents
      */
@@ -903,7 +937,7 @@ declare class CollaborativePlanner {
  *
  * Key concepts:
  * - Space: Project container with shared configuration
- * - Task: Individual conversation threads within a space
+ * - Task: Individual conversation tasks within a space
  * - Each task has its own conversation history and artifacts
  */
 
@@ -917,15 +951,14 @@ interface SpaceTask {
     createdAt: Date;
     updatedAt: Date;
 }
-declare class Space$1 {
+declare class Space {
     spaceId: string;
     userId?: string;
     config: SpaceConfig;
     history: ConversationHistory;
     tasks: Map<string, SpaceTask>;
     messageQueue: MessageQueue;
-    agents: Map<string, Agent$1>;
-    storage: SpaceStorage;
+    agents: Map<string, Agent>;
     goal: string;
     name: string;
     viberAgent?: ViberAgent;
@@ -936,14 +969,13 @@ declare class Space$1 {
     collaborationManager?: AgentCollaborationManager;
     parallelEngine?: ParallelExecutionEngine;
     collaborativePlanner?: CollaborativePlanner;
-    constructor({ spaceId, userId, config, history, messageQueue, agents, storage, goal, name, viberAgent, }: {
+    constructor({ spaceId, userId, config, history, messageQueue, agents, goal, name, viberAgent, }: {
         spaceId: string;
         userId?: string;
         config: SpaceConfig;
         history: ConversationHistory;
         messageQueue: MessageQueue;
-        agents: Map<string, Agent$1>;
-        storage: SpaceStorage;
+        agents: Map<string, Agent>;
         goal: string;
         name?: string;
         viberAgent?: ViberAgent;
@@ -964,20 +996,32 @@ declare class Space$1 {
      * 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;
+    getAgent(name: string): Agent | undefined;
+    registerAgent(name: string, agent: Agent): 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[]>;
+    getNextTask(): Promise<Task | undefined>;
+    getParallelTasks(maxTasks?: number): Promise<Task[]>;
     updateTaskStatus(taskId: string, status: TaskStatus): Promise<boolean>;
     assignTask(taskId: string, agentName: string): Promise<boolean>;
     isPlanComplete(): boolean;
     hasFailedTasks(): boolean;
+    /**
+     * Persist state
+     *
+     * @deprecated Space persistence is now handled by the API layer using SupabaseDatabaseAdapter.
+     * This method is a no-op kept for interface compatibility.
+     */
     persistState(): Promise<void>;
+    /**
+     * Load state
+     *
+     * @deprecated Space data is loaded from the database.
+     * This method is a no-op kept for interface compatibility.
+     */
     loadState(): Promise<boolean>;
     loadPlan(): Promise<Plan | undefined>;
     getState(): SpaceState;
@@ -992,7 +1036,7 @@ declare function startSpace({ goal, spaceId, userId, spaceRoot, name, model, }:
     spaceRoot?: string;
     name?: string;
     model?: string;
-}): Promise<Space$1>;
+}): Promise<Space>;
 
 /**
  * AI Provider Management
@@ -1006,12 +1050,14 @@ declare function startSpace({ goal, spaceId, userId, spaceRoot, name, model, }:
  * 3. Add case: `case "google": return createGoogleGenerativeAI({...})`
  * 4. Add environment variable handling
  */
-type ModelProvider$1 = string;
-interface ModelConfig$1 {
-    provider: ModelProvider$1;
+type ModelProvider = string;
+interface ModelConfig {
+    provider: ModelProvider;
     modelName: string;
     apiKey?: string;
     baseURL?: string;
+    /** Optional proxy-aware fetch to route API calls through an HTTP proxy */
+    proxyFetch?: typeof fetch;
     spaceId?: string;
     userId?: string;
     storageRoot?: string;
@@ -1021,680 +1067,11 @@ interface ModelConfig$1 {
 /**
  * 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;
+declare function getModelProvider(config: ModelConfig): _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;
-    appId?: string;
-} | {
-    type: "terminal:detach";
-    target: string;
-    appId?: string;
-} | {
-    type: "terminal:input";
-    target: string;
-    keys: string;
-    appId?: string;
-} | {
-    type: "terminal:resize";
-    target: string;
-    cols: number;
-    rows: number;
-    appId?: string;
-};
-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";
-    apps: any[];
-    sessions: any[];
-    panes: any[];
-} | {
-    type: "terminal:attached";
-    target: string;
-    appId?: string;
-    ok: boolean;
-    error?: string;
-} | {
-    type: "terminal:detached";
-    target: string;
-    appId?: string;
-} | {
-    type: "terminal:output";
-    target: string;
-    appId?: string;
-    data: string;
-} | {
-    type: "terminal:resized";
-    target: string;
-    appId?: 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;
-}>;
+declare function parseModelString(model: string): ModelConfig;
 
-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 };
+export { Agent, AgentCollaborationManager, type AgentContext, type AgentData, type AgentMessage, type AgentResponse, type ArtifactData, CollaborativePlanner, type ConversationData, ConversationHistory, type CoreTool, type DatasourceData, type Message, MessageQueue, type ModelConfig$1 as ModelConfig, type ModelProvider, type ModelProviderData, ParallelExecutionEngine, type ParallelExecutionResult, type ParallelTask, Plan, type PlanSummary, type ProviderModelConfig, type QueueListener, type QueueState, type QueuedMessage, type SharedContext, Space, type SpaceConfig, type SpaceData, type SpaceModel, type SpaceState, type SpaceTask, type StreamChunk, Task, type TaskData, type TaskDependency, TaskStatus, type TaskStep, type ToolContext, type ToolData, type ToolProgressCallback, ViberAgent, type ViberAgentResponse, type ViberConfig, type ViberError, type ViberMessage, type ViberOptions, type ViberStreamOptions, type WorkingMode, applyWorkingModeToTools, buildToolMap, clearToolCache, getModelProvider, getTextContent, hasToolApproval, isValidTool, parseModelString, resolveRequireApprovalTools, resolveWorkingMode, startSpace };