kyber-chat 1.0.0__py3-none-any.whl

kyber/config/__init__.py

@@ -0,0 +1,6 @@
+"""Configuration module for kyber."""
+
+from kyber.config.loader import load_config, get_config_path
+from kyber.config.schema import Config
+
+__all__ = ["Config", "load_config", "get_config_path"]

kyber/config/loader.py

@@ -0,0 +1,95 @@
+"""Configuration loading utilities."""
+
+import json
+from pathlib import Path
+from typing import Any
+
+from kyber.config.schema import Config
+
+
+def get_config_path() -> Path:
+    """Get the default configuration file path."""
+    return Path.home() / ".kyber" / "config.json"
+
+
+def get_data_dir() -> Path:
+    """Get the kyber data directory."""
+    from kyber.utils.helpers import get_data_path
+    return get_data_path()
+
+
+def load_config(config_path: Path | None = None) -> Config:
+    """
+    Load configuration from file or create default.
+    
+    Args:
+        config_path: Optional path to config file. Uses default if not provided.
+    
+    Returns:
+        Loaded configuration object.
+    """
+    path = config_path or get_config_path()
+    
+    if path.exists():
+        try:
+            with open(path) as f:
+                data = json.load(f)
+            return Config.model_validate(convert_keys(data))
+        except (json.JSONDecodeError, ValueError) as e:
+            print(f"Warning: Failed to load config from {path}: {e}")
+            print("Using default configuration.")
+    
+    return Config()
+
+
+def save_config(config: Config, config_path: Path | None = None) -> None:
+    """
+    Save configuration to file.
+    
+    Args:
+        config: Configuration to save.
+        config_path: Optional path to save to. Uses default if not provided.
+    """
+    path = config_path or get_config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    
+    # Convert to camelCase format
+    data = config.model_dump()
+    data = convert_to_camel(data)
+    
+    with open(path, "w") as f:
+        json.dump(data, f, indent=2)
+
+
+def convert_keys(data: Any) -> Any:
+    """Convert camelCase keys to snake_case for Pydantic."""
+    if isinstance(data, dict):
+        return {camel_to_snake(k): convert_keys(v) for k, v in data.items()}
+    if isinstance(data, list):
+        return [convert_keys(item) for item in data]
+    return data
+
+
+def convert_to_camel(data: Any) -> Any:
+    """Convert snake_case keys to camelCase."""
+    if isinstance(data, dict):
+        return {snake_to_camel(k): convert_to_camel(v) for k, v in data.items()}
+    if isinstance(data, list):
+        return [convert_to_camel(item) for item in data]
+    return data
+
+
+def camel_to_snake(name: str) -> str:
+    """Convert camelCase to snake_case."""
+    result = []
+    for i, char in enumerate(name):
+        if char.isupper() and i > 0:
+            result.append("_")
+        result.append(char.lower())
+    return "".join(result)
+
+
+def snake_to_camel(name: str) -> str:
+    """Convert snake_case to camelCase."""
+    components = name.split("_")
+    return components[0] + "".join(x.title() for x in components[1:])

kyber/config/schema.py

@@ -0,0 +1,205 @@
+"""Configuration schema using Pydantic."""
+
+from pathlib import Path
+from pydantic import BaseModel, Field
+from pydantic_settings import BaseSettings
+
+
+class WhatsAppConfig(BaseModel):
+    """WhatsApp channel configuration."""
+    enabled: bool = False
+    bridge_url: str = "ws://localhost:3001"
+    allow_from: list[str] = Field(default_factory=list)  # Allowed phone numbers
+
+
+class TelegramConfig(BaseModel):
+    """Telegram channel configuration."""
+    enabled: bool = False
+    token: str = ""  # Bot token from @BotFather
+    allow_from: list[str] = Field(default_factory=list)  # Allowed user IDs or usernames
+    proxy: str | None = None  # HTTP/SOCKS5 proxy URL, e.g. "http://127.0.0.1:7890" or "socks5://127.0.0.1:1080"
+
+
+class FeishuConfig(BaseModel):
+    """Feishu/Lark channel configuration using WebSocket long connection."""
+    enabled: bool = False
+    app_id: str = ""  # App ID from Feishu Open Platform
+    app_secret: str = ""  # App Secret from Feishu Open Platform
+    encrypt_key: str = ""  # Encrypt Key for event subscription (optional)
+    verification_token: str = ""  # Verification Token for event subscription (optional)
+    allow_from: list[str] = Field(default_factory=list)  # Allowed user open_ids
+
+
+class DiscordConfig(BaseModel):
+    """Discord channel configuration."""
+    enabled: bool = False
+    token: str = ""  # Bot token from Discord Developer Portal
+    allow_from: list[str] = Field(default_factory=list)  # Allowed user IDs or usernames
+    allow_guilds: list[str] = Field(default_factory=list)  # Allowed guild IDs (servers)
+    allow_channels: list[str] = Field(default_factory=list)  # Allowed channel IDs
+    require_mention_in_guilds: bool = True  # Only respond in guilds when mentioned/replied
+    max_attachment_mb: int = 20  # Max attachment size to download
+    typing_indicator: bool = True  # Show "typing" while processing
+
+
+class ChannelsConfig(BaseModel):
+    """Configuration for chat channels."""
+    whatsapp: WhatsAppConfig = Field(default_factory=WhatsAppConfig)
+    telegram: TelegramConfig = Field(default_factory=TelegramConfig)
+    feishu: FeishuConfig = Field(default_factory=FeishuConfig)
+    discord: DiscordConfig = Field(default_factory=DiscordConfig)
+
+
+class AgentDefaults(BaseModel):
+    """Default agent configuration."""
+    workspace: str = "~/.kyber/workspace"
+    model: str = "google/gemini-2.5-flash-preview"
+    provider: str = "openrouter"  # Default provider
+    max_tokens: int = 8192
+    temperature: float = 0.7
+    max_tool_iterations: int = 20
+
+
+class AgentsConfig(BaseModel):
+    """Agent configuration."""
+    defaults: AgentDefaults = Field(default_factory=AgentDefaults)
+
+
+class ProviderConfig(BaseModel):
+    """LLM provider configuration."""
+    api_key: str = ""
+    api_base: str | None = None
+
+
+class ProvidersConfig(BaseModel):
+    """Configuration for LLM providers."""
+    anthropic: ProviderConfig = Field(default_factory=ProviderConfig)
+    openai: ProviderConfig = Field(default_factory=ProviderConfig)
+    openrouter: ProviderConfig = Field(default_factory=ProviderConfig)
+    deepseek: ProviderConfig = Field(default_factory=ProviderConfig)
+    groq: ProviderConfig = Field(default_factory=ProviderConfig)
+    zhipu: ProviderConfig = Field(default_factory=ProviderConfig)
+    vllm: ProviderConfig = Field(default_factory=ProviderConfig)
+    gemini: ProviderConfig = Field(default_factory=ProviderConfig)
+
+
+class GatewayConfig(BaseModel):
+    """Gateway/server configuration."""
+    host: str = "0.0.0.0"
+    port: int = 18790
+
+
+class WebSearchConfig(BaseModel):
+    """Web search tool configuration."""
+    api_key: str = ""  # Brave Search API key
+    max_results: int = 5
+
+
+class WebToolsConfig(BaseModel):
+    """Web tools configuration."""
+    search: WebSearchConfig = Field(default_factory=WebSearchConfig)
+
+
+
+class DashboardConfig(BaseModel):
+    """Web dashboard configuration."""
+    host: str = "127.0.0.1"
+    port: int = 18890
+    auth_token: str = ""  # Bearer token for dashboard access
+    allowed_hosts: list[str] = Field(default_factory=list)  # Extra allowed Host headers
+
+
+class ExecToolConfig(BaseModel):
+    """Shell exec tool configuration."""
+    timeout: int = 60
+    restrict_to_workspace: bool = False  # If true, block commands accessing paths outside workspace
+
+
+class ToolsConfig(BaseModel):
+    """Tools configuration."""
+    web: WebToolsConfig = Field(default_factory=WebToolsConfig)
+    exec: ExecToolConfig = Field(default_factory=ExecToolConfig)
+
+
+class Config(BaseSettings):
+    """Root configuration for kyber."""
+    agents: AgentsConfig = Field(default_factory=AgentsConfig)
+    channels: ChannelsConfig = Field(default_factory=ChannelsConfig)
+    providers: ProvidersConfig = Field(default_factory=ProvidersConfig)
+    gateway: GatewayConfig = Field(default_factory=GatewayConfig)
+    dashboard: DashboardConfig = Field(default_factory=DashboardConfig)
+    tools: ToolsConfig = Field(default_factory=ToolsConfig)
+    
+    @property
+    def workspace_path(self) -> Path:
+        """Get expanded workspace path."""
+        return Path(self.agents.defaults.workspace).expanduser()
+
+    def _preferred_provider(self) -> str | None:
+        """Return the explicitly configured provider, if any."""
+        value = (self.agents.defaults.provider or "").strip().lower()
+        return value or None
+    
+    def get_api_key(self) -> str | None:
+        """Get API key in priority order, unless a provider is explicitly set."""
+        preferred = self._preferred_provider()
+        if preferred:
+            provider = getattr(self.providers, preferred, None)
+            return provider.api_key if provider else None
+        return (
+            self.providers.openrouter.api_key or
+            self.providers.deepseek.api_key or
+            self.providers.anthropic.api_key or
+            self.providers.openai.api_key or
+            self.providers.gemini.api_key or
+            self.providers.zhipu.api_key or
+            self.providers.groq.api_key or
+            self.providers.vllm.api_key or
+            None
+        )
+    
+    def get_api_base(self) -> str | None:
+        """Get API base URL if using OpenRouter, Zhipu or vLLM."""
+        preferred = self._preferred_provider()
+        if preferred == "openrouter":
+            return self.providers.openrouter.api_base or "https://openrouter.ai/api/v1"
+        if preferred == "zhipu":
+            return self.providers.zhipu.api_base
+        if preferred == "vllm":
+            return self.providers.vllm.api_base
+        if preferred:
+            return None
+        if self.providers.openrouter.api_key:
+            return self.providers.openrouter.api_base or "https://openrouter.ai/api/v1"
+        if self.providers.zhipu.api_key:
+            return self.providers.zhipu.api_base
+        if self.providers.vllm.api_base:
+            return self.providers.vllm.api_base
+        return None
+
+    def get_provider_name(self) -> str | None:
+        """Return the selected provider name based on configured keys."""
+        preferred = self._preferred_provider()
+        if preferred:
+            return preferred if hasattr(self.providers, preferred) else None
+        if self.providers.openrouter.api_key:
+            return "openrouter"
+        if self.providers.deepseek.api_key:
+            return "deepseek"
+        if self.providers.anthropic.api_key:
+            return "anthropic"
+        if self.providers.openai.api_key:
+            return "openai"
+        if self.providers.gemini.api_key:
+            return "gemini"
+        if self.providers.zhipu.api_key:
+            return "zhipu"
+        if self.providers.groq.api_key:
+            return "groq"
+        if self.providers.vllm.api_base or self.providers.vllm.api_key:
+            return "vllm"
+        return None
+    
+    class Config:
+        env_prefix = "KYBER_"
+        env_nested_delimiter = "__"

kyber/cron/__init__.py

@@ -0,0 +1,6 @@
+"""Cron service for scheduled agent tasks."""
+
+from kyber.cron.service import CronService
+from kyber.cron.types import CronJob, CronSchedule
+
+__all__ = ["CronService", "CronJob", "CronSchedule"]

kyber/cron/service.py

@@ -0,0 +1,346 @@
+"""Cron service for scheduling agent tasks."""
+
+import asyncio
+import json
+import time
+import uuid
+from pathlib import Path
+from typing import Any, Callable, Coroutine
+
+from loguru import logger
+
+from kyber.cron.types import CronJob, CronJobState, CronPayload, CronSchedule, CronStore
+
+
+def _now_ms() -> int:
+    return int(time.time() * 1000)
+
+
+def _compute_next_run(schedule: CronSchedule, now_ms: int) -> int | None:
+    """Compute next run time in ms."""
+    if schedule.kind == "at":
+        return schedule.at_ms if schedule.at_ms and schedule.at_ms > now_ms else None
+    
+    if schedule.kind == "every":
+        if not schedule.every_ms or schedule.every_ms <= 0:
+            return None
+        # Next interval from now
+        return now_ms + schedule.every_ms
+    
+    if schedule.kind == "cron" and schedule.expr:
+        try:
+            from croniter import croniter
+            cron = croniter(schedule.expr, time.time())
+            next_time = cron.get_next()
+            return int(next_time * 1000)
+        except Exception:
+            return None
+    
+    return None
+
+
+class CronService:
+    """Service for managing and executing scheduled jobs."""
+    
+    def __init__(
+        self,
+        store_path: Path,
+        on_job: Callable[[CronJob], Coroutine[Any, Any, str | None]] | None = None
+    ):
+        self.store_path = store_path
+        self.on_job = on_job  # Callback to execute job, returns response text
+        self._store: CronStore | None = None
+        self._timer_task: asyncio.Task | None = None
+        self._running = False
+    
+    def _load_store(self) -> CronStore:
+        """Load jobs from disk."""
+        if self._store:
+            return self._store
+        
+        if self.store_path.exists():
+            try:
+                data = json.loads(self.store_path.read_text())
+                jobs = []
+                for j in data.get("jobs", []):
+                    jobs.append(CronJob(
+                        id=j["id"],
+                        name=j["name"],
+                        enabled=j.get("enabled", True),
+                        schedule=CronSchedule(
+                            kind=j["schedule"]["kind"],
+                            at_ms=j["schedule"].get("atMs"),
+                            every_ms=j["schedule"].get("everyMs"),
+                            expr=j["schedule"].get("expr"),
+                            tz=j["schedule"].get("tz"),
+                        ),
+                        payload=CronPayload(
+                            kind=j["payload"].get("kind", "agent_turn"),
+                            message=j["payload"].get("message", ""),
+                            deliver=j["payload"].get("deliver", False),
+                            channel=j["payload"].get("channel"),
+                            to=j["payload"].get("to"),
+                        ),
+                        state=CronJobState(
+                            next_run_at_ms=j.get("state", {}).get("nextRunAtMs"),
+                            last_run_at_ms=j.get("state", {}).get("lastRunAtMs"),
+                            last_status=j.get("state", {}).get("lastStatus"),
+                            last_error=j.get("state", {}).get("lastError"),
+                        ),
+                        created_at_ms=j.get("createdAtMs", 0),
+                        updated_at_ms=j.get("updatedAtMs", 0),
+                        delete_after_run=j.get("deleteAfterRun", False),
+                    ))
+                self._store = CronStore(jobs=jobs)
+            except Exception as e:
+                logger.warning(f"Failed to load cron store: {e}")
+                self._store = CronStore()
+        else:
+            self._store = CronStore()
+        
+        return self._store
+    
+    def _save_store(self) -> None:
+        """Save jobs to disk."""
+        if not self._store:
+            return
+        
+        self.store_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        data = {
+            "version": self._store.version,
+            "jobs": [
+                {
+                    "id": j.id,
+                    "name": j.name,
+                    "enabled": j.enabled,
+                    "schedule": {
+                        "kind": j.schedule.kind,
+                        "atMs": j.schedule.at_ms,
+                        "everyMs": j.schedule.every_ms,
+                        "expr": j.schedule.expr,
+                        "tz": j.schedule.tz,
+                    },
+                    "payload": {
+                        "kind": j.payload.kind,
+                        "message": j.payload.message,
+                        "deliver": j.payload.deliver,
+                        "channel": j.payload.channel,
+                        "to": j.payload.to,
+                    },
+                    "state": {
+                        "nextRunAtMs": j.state.next_run_at_ms,
+                        "lastRunAtMs": j.state.last_run_at_ms,
+                        "lastStatus": j.state.last_status,
+                        "lastError": j.state.last_error,
+                    },
+                    "createdAtMs": j.created_at_ms,
+                    "updatedAtMs": j.updated_at_ms,
+                    "deleteAfterRun": j.delete_after_run,
+                }
+                for j in self._store.jobs
+            ]
+        }
+        
+        self.store_path.write_text(json.dumps(data, indent=2))
+    
+    async def start(self) -> None:
+        """Start the cron service."""
+        self._running = True
+        self._load_store()
+        self._recompute_next_runs()
+        self._save_store()
+        self._arm_timer()
+        logger.info(f"Cron service started with {len(self._store.jobs if self._store else [])} jobs")
+    
+    def stop(self) -> None:
+        """Stop the cron service."""
+        self._running = False
+        if self._timer_task:
+            self._timer_task.cancel()
+            self._timer_task = None
+    
+    def _recompute_next_runs(self) -> None:
+        """Recompute next run times for all enabled jobs."""
+        if not self._store:
+            return
+        now = _now_ms()
+        for job in self._store.jobs:
+            if job.enabled:
+                job.state.next_run_at_ms = _compute_next_run(job.schedule, now)
+    
+    def _get_next_wake_ms(self) -> int | None:
+        """Get the earliest next run time across all jobs."""
+        if not self._store:
+            return None
+        times = [j.state.next_run_at_ms for j in self._store.jobs 
+                 if j.enabled and j.state.next_run_at_ms]
+        return min(times) if times else None
+    
+    def _arm_timer(self) -> None:
+        """Schedule the next timer tick."""
+        if self._timer_task:
+            self._timer_task.cancel()
+        
+        next_wake = self._get_next_wake_ms()
+        if not next_wake or not self._running:
+            return
+        
+        delay_ms = max(0, next_wake - _now_ms())
+        delay_s = delay_ms / 1000
+        
+        async def tick():
+            await asyncio.sleep(delay_s)
+            if self._running:
+                await self._on_timer()
+        
+        self._timer_task = asyncio.create_task(tick())
+    
+    async def _on_timer(self) -> None:
+        """Handle timer tick - run due jobs."""
+        if not self._store:
+            return
+        
+        now = _now_ms()
+        due_jobs = [
+            j for j in self._store.jobs
+            if j.enabled and j.state.next_run_at_ms and now >= j.state.next_run_at_ms
+        ]
+        
+        for job in due_jobs:
+            await self._execute_job(job)
+        
+        self._save_store()
+        self._arm_timer()
+    
+    async def _execute_job(self, job: CronJob) -> None:
+        """Execute a single job."""
+        start_ms = _now_ms()
+        logger.info(f"Cron: executing job '{job.name}' ({job.id})")
+        
+        try:
+            response = None
+            if self.on_job:
+                response = await self.on_job(job)
+            
+            job.state.last_status = "ok"
+            job.state.last_error = None
+            logger.info(f"Cron: job '{job.name}' completed")
+            
+        except Exception as e:
+            job.state.last_status = "error"
+            job.state.last_error = str(e)
+            logger.error(f"Cron: job '{job.name}' failed: {e}")
+        
+        job.state.last_run_at_ms = start_ms
+        job.updated_at_ms = _now_ms()
+        
+        # Handle one-shot jobs
+        if job.schedule.kind == "at":
+            if job.delete_after_run:
+                self._store.jobs = [j for j in self._store.jobs if j.id != job.id]
+            else:
+                job.enabled = False
+                job.state.next_run_at_ms = None
+        else:
+            # Compute next run
+            job.state.next_run_at_ms = _compute_next_run(job.schedule, _now_ms())
+    
+    # ========== Public API ==========
+    
+    def list_jobs(self, include_disabled: bool = False) -> list[CronJob]:
+        """List all jobs."""
+        store = self._load_store()
+        jobs = store.jobs if include_disabled else [j for j in store.jobs if j.enabled]
+        return sorted(jobs, key=lambda j: j.state.next_run_at_ms or float('inf'))
+    
+    def add_job(
+        self,
+        name: str,
+        schedule: CronSchedule,
+        message: str,
+        deliver: bool = False,
+        channel: str | None = None,
+        to: str | None = None,
+        delete_after_run: bool = False,
+    ) -> CronJob:
+        """Add a new job."""
+        store = self._load_store()
+        now = _now_ms()
+        
+        job = CronJob(
+            id=str(uuid.uuid4())[:8],
+            name=name,
+            enabled=True,
+            schedule=schedule,
+            payload=CronPayload(
+                kind="agent_turn",
+                message=message,
+                deliver=deliver,
+                channel=channel,
+                to=to,
+            ),
+            state=CronJobState(next_run_at_ms=_compute_next_run(schedule, now)),
+            created_at_ms=now,
+            updated_at_ms=now,
+            delete_after_run=delete_after_run,
+        )
+        
+        store.jobs.append(job)
+        self._save_store()
+        self._arm_timer()
+        
+        logger.info(f"Cron: added job '{name}' ({job.id})")
+        return job
+    
+    def remove_job(self, job_id: str) -> bool:
+        """Remove a job by ID."""
+        store = self._load_store()
+        before = len(store.jobs)
+        store.jobs = [j for j in store.jobs if j.id != job_id]
+        removed = len(store.jobs) < before
+        
+        if removed:
+            self._save_store()
+            self._arm_timer()
+            logger.info(f"Cron: removed job {job_id}")
+        
+        return removed
+    
+    def enable_job(self, job_id: str, enabled: bool = True) -> CronJob | None:
+        """Enable or disable a job."""
+        store = self._load_store()
+        for job in store.jobs:
+            if job.id == job_id:
+                job.enabled = enabled
+                job.updated_at_ms = _now_ms()
+                if enabled:
+                    job.state.next_run_at_ms = _compute_next_run(job.schedule, _now_ms())
+                else:
+                    job.state.next_run_at_ms = None
+                self._save_store()
+                self._arm_timer()
+                return job
+        return None
+    
+    async def run_job(self, job_id: str, force: bool = False) -> bool:
+        """Manually run a job."""
+        store = self._load_store()
+        for job in store.jobs:
+            if job.id == job_id:
+                if not force and not job.enabled:
+                    return False
+                await self._execute_job(job)
+                self._save_store()
+                self._arm_timer()
+                return True
+        return False
+    
+    def status(self) -> dict:
+        """Get service status."""
+        store = self._load_store()
+        return {
+            "enabled": self._running,
+            "jobs": len(store.jobs),
+            "next_wake_at_ms": self._get_next_wake_ms(),
+        }