calvyn-code 0.14.10 → 0.14.11

package/cli.py

@@ -2679,7 +2679,7 @@ class HermesCLI:
         # env vars would stomp each other.
         _model_config = CLI_CONFIG.get("model", {})
         _config_model = (_model_config.get("default") or _model_config.get("model") or "") if isinstance(_model_config, dict) else (_model_config or "")
-        _DEFAULT_CONFIG_MODEL = ""
+        _DEFAULT_CONFIG_MODEL = "gpt-5.3-codex"
         self.model = model or _config_model or _DEFAULT_CONFIG_MODEL
         # Auto-detect model from local server if still on default
         if self.model == _DEFAULT_CONFIG_MODEL:
@@ -4618,7 +4618,10 @@ class HermesCLI:
         self._console_print()
         self._console_print()
         term_width = shutil.get_terminal_size().columns
-        if term_width >= 95:
+        _early_banner_shown = os.getenv("CALVYN_EARLY_BANNER_SHOWN", "").strip().lower() in {
+            "1", "true", "yes", "on",
+        }
+        if term_width >= 95 and not _early_banner_shown:
             self._console_print(_logo)
             self._console_print()
         self._console_print(_build_compact_banner())
@@ -6901,13 +6904,15 @@ class HermesCLI:
             _cprint("    Prompt caching: enabled")
         if result.warning_message:
             _cprint(f"    ⚠ {result.warning_message}")
-        if persist_global:
-            save_config_value("model.default", result.new_model)
-            if result.provider_changed:
-                save_config_value("model.provider", result.target_provider)
-            _cprint("    Saved to config.yaml (--global)")
-        else:
-            _cprint("    (session only — add --global to persist)")
+        if persist_global:
+            save_config_value("model.default", result.new_model)
+            if result.provider_changed:
+                save_config_value("model.provider", result.target_provider)
+            _cprint("    Saved to config.yaml (--global)")
+        else:
+            save_config_value("model.default", result.new_model)
+            save_config_value("model.provider", result.target_provider)
+            _cprint("    Saved to config.yaml")
 
     def _handle_model_picker_selection(self, persist_global: bool = False) -> None:
         state = self._model_picker_state
@@ -7144,13 +7149,15 @@ class HermesCLI:
             _cprint(f"    ⚠ {result.warning_message}")
 
         # Persistence
-        if persist_global:
-            save_config_value("model.default", result.new_model)
-            if result.provider_changed:
-                save_config_value("model.provider", result.target_provider)
-            _cprint("    Saved to config.yaml (--global)")
-        else:
-            _cprint("    (session only — add --global to persist)")
+        if persist_global:
+            save_config_value("model.default", result.new_model)
+            if result.provider_changed:
+                save_config_value("model.provider", result.target_provider)
+            _cprint("    Saved to config.yaml (--global)")
+        else:
+            save_config_value("model.default", result.new_model)
+            save_config_value("model.provider", result.target_provider)
+            _cprint("    Saved to config.yaml")
 
     def _handle_codex_runtime(self, cmd_original: str) -> None:
         """Handle /codex-runtime — toggle the codex app-server runtime opt-in.

package/hermes_cli/model_switch.py

@@ -170,7 +170,23 @@ class DirectAlias(NamedTuple):
 
 
 # Built-in direct aliases (can be extended via config.yaml model_aliases:)
-_BUILTIN_DIRECT_ALIASES: dict[str, DirectAlias] = {}
+_BUILTIN_DIRECT_ALIASES: dict[str, DirectAlias] = {
+    "freemodel/gpt": DirectAlias(
+        model="gpt-5.3-codex",
+        provider="freemodel",
+        base_url="https://freemodel.dev/v1",
+    ),
+    "freemodel/gpt-5.3-codex": DirectAlias(
+        model="gpt-5.3-codex",
+        provider="freemodel",
+        base_url="https://freemodel.dev/v1",
+    ),
+    "openai/gpt": DirectAlias(
+        model="gpt-5.4",
+        provider="openai",
+        base_url="",
+    ),
+}
 
 # Merged dict (builtins + user config); populated by _load_direct_aliases()
 DIRECT_ALIASES: dict[str, DirectAlias] = {}

package/hermes_cli/models.py

@@ -189,11 +189,12 @@ _PROVIDER_MODELS: dict[str, list[str]] = {
     ],
     # Native OpenAI Chat Completions (api.openai.com). Used by /model counts and
     # provider_model_ids fallback when /v1/models is unavailable.
-    "openai": [
-        "gpt-5.4",
-        "gpt-5.4-mini",
-        "gpt-5-mini",
-        "gpt-5.3-codex",
+    "openai": [
+        "openai/gpt",
+        "gpt-5.4",
+        "gpt-5.4-mini",
+        "gpt-5-mini",
+        "gpt-5.3-codex",
         "gpt-5.2-codex",
         "gpt-4.1",
         "gpt-4o",
@@ -340,6 +341,8 @@ _PROVIDER_MODELS: dict[str, list[str]] = {
         "openai/gpt-5.4",
     ],
     "freemodel": [
+        "freemodel/gpt",
+        "freemodel/gpt-5.3-codex",
         "gpt-5.5",
         "gpt-5.4",
         "gpt-5.4-mini",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "calvyn-code",
-  "version": "0.14.10",
+  "version": "0.14.11",
   "description": "Calvyn Code — AI агент с инструментами, мессенджерами и локальным CLI",
   "bin": {
     "calvyn": "bin/calvyn.js",

package/plugins/platforms/vk/__init__.py

@@ -0,0 +1,3 @@
+from .adapter import register
+
+__all__ = ["register"]

package/plugins/platforms/vk/adapter.py

@@ -0,0 +1,105 @@
+import asyncio
+import logging
+import os
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+try:
+    from vkbottle.bot import Bot
+    from vkbottle import Message
+    VKBOTTLE_AVAILABLE = True
+except Exception:
+    Bot = Any
+    Message = Any
+    VKBOTTLE_AVAILABLE = False
+
+from gateway.config import Platform, PlatformConfig
+from gateway.platforms.base import BasePlatformAdapter, MessageEvent, MessageType, SendResult
+from gateway.session import SessionSource
+
+
+def check_requirements() -> bool:
+    if VKBOTTLE_AVAILABLE:
+        return True
+    try:
+        from tools.lazy_deps import ensure as _ensure
+        _ensure("platform.vk", prompt=False)
+    except Exception:
+        return False
+    return True
+
+
+class VKAdapter(BasePlatformAdapter):
+    def __init__(self, config):
+        super().__init__(config=config, platform=Platform("vk"))
+        extra = getattr(config, "extra", {}) or {}
+        self.token = os.getenv("VK_BOT_TOKEN") or getattr(config, "token", "") or extra.get("token", "")
+        self.allowed_users = {str(x).strip() for x in (os.getenv("VK_ALLOWED_USERS", "") or extra.get("allowed_users", "") or "").split(",") if str(x).strip()}
+        self.allow_all = str(os.getenv("VK_ALLOW_ALL_USERS", "") or extra.get("allow_all_users", "") or "").lower() in {"1","true","yes","on"}
+        self.home_channel = os.getenv("VK_HOME_CHANNEL") or extra.get("home_channel", "")
+        self._bot = None
+        self._task = None
+
+    async def connect(self) -> bool:
+        if not self.token:
+            self._set_fatal_error("missing_token", "VK_BOT_TOKEN is required", retryable=False)
+            return False
+        self._bot = Bot(token=self.token)
+
+        @self._bot.on.message()
+        async def _on_message(message: Message):
+            if getattr(message, "out", False):
+                return
+            user_id = str(getattr(message, "from_id", "") or "")
+            if not self.allow_all and self.allowed_users and user_id not in self.allowed_users:
+                return
+            text = (getattr(message, "text", "") or "").strip()
+            if not text:
+                return
+            peer_id = str(getattr(message, "peer_id", "") or "")
+            source = SessionSource(platform=Platform("vk"), chat_id=peer_id, user_id=user_id, chat_type="dm" if peer_id and peer_id.isdigit() and int(peer_id) < 2_000_000_000 else "group")
+            event = MessageEvent(text=text, message_type=MessageType.TEXT, source=source, raw_message=message, message_id=str(getattr(message, "conversation_message_id", "") or ""))
+            await self.handle_message(event)
+
+        self._task = asyncio.create_task(self._bot.run_forever())
+        self._mark_connected()
+        return True
+
+    async def disconnect(self) -> None:
+        self._mark_disconnected()
+        if self._task and not self._task.done():
+            self._task.cancel()
+        self._task = None
+
+    async def send(self, chat_id: str, content: str, reply_to: Optional[str] = None, metadata: Optional[dict] = None, **kwargs) -> SendResult:
+        if not self._bot:
+            return SendResult(success=False, error="VK bot not connected")
+        try:
+            await self._bot.api.messages.send(peer_id=int(chat_id), random_id=0, message=content)
+            return SendResult(success=True, message_id="vk")
+        except Exception as exc:
+            return SendResult(success=False, error=str(exc))
+
+    async def send_typing(self, chat_id: str) -> None:
+        return None
+
+    async def get_chat_info(self, chat_id: str) -> dict:
+        return {"name": chat_id, "type": "dm", "chat_id": chat_id}
+
+
+def register(ctx):
+    ctx.register_platform(
+        name="vk",
+        label="VK",
+        adapter_factory=lambda cfg: VKAdapter(cfg),
+        check_fn=check_requirements,
+        required_env=["VK_BOT_TOKEN"],
+        env_enablement_fn=lambda: {"token": os.getenv("VK_BOT_TOKEN", "")} if os.getenv("VK_BOT_TOKEN") else None,
+        cron_deliver_env_var="VK_HOME_CHANNEL",
+        allowed_users_env="VK_ALLOWED_USERS",
+        allow_all_env="VK_ALLOW_ALL_USERS",
+        emoji="💬",
+        pii_safe=False,
+        platform_hint="You are chatting in VK. Keep replies concise and plain-text friendly.",
+    )

package/plugins/platforms/vk/plugin.yaml

@@ -0,0 +1,25 @@
+name: vk-platform
+label: VK
+kind: platform
+version: 1.0.0
+description: >
+  VK gateway adapter for Calvyn Code.
+author: Zanderrr
+requires_env:
+  - name: VK_BOT_TOKEN
+    description: "VK community token for the bot"
+    prompt: "VK token"
+    password: true
+optional_env:
+  - name: VK_ALLOWED_USERS
+    description: "Comma-separated VK user IDs allowed to talk to the bot"
+    prompt: "Allowed users"
+    password: false
+  - name: VK_ALLOW_ALL_USERS
+    description: "Allow any VK user to talk to the bot"
+    prompt: "Allow all users? (true/false)"
+    password: false
+  - name: VK_HOME_CHANNEL
+    description: "Chat ID used for cron delivery"
+    prompt: "VK home channel"
+    password: false

package/pyproject.toml

@@ -81,7 +81,7 @@ daytona = ["daytona==0.155.0"]
 vercel = ["vercel==0.5.7"]
 hindsight = ["hindsight-client==0.6.1"]
 dev = ["debugpy==1.8.20", "pytest==9.0.2", "pytest-asyncio==1.3.0", "pytest-xdist==3.8.0", "pytest-split==0.11.0", "mcp==1.26.0", "ty==0.0.21", "ruff==0.15.10"]
-messaging = ["python-telegram-bot[webhooks]==22.6", "discord.py[voice]==2.7.1", "aiohttp==3.13.3", "brotlicffi==1.2.0.1", "slack-bolt==1.27.0", "slack-sdk==3.40.1", "qrcode==7.4.2"]
+messaging = ["python-telegram-bot[webhooks]==22.6", "discord.py[voice]==2.7.1", "aiohttp==3.13.3", "brotlicffi==1.2.0.1", "slack-bolt==1.27.0", "slack-sdk==3.40.1", "qrcode==7.4.2", "vkbottle==4.6.2"]
 cron = []  # croniter is now a core dependency; this extra kept for back-compat
 slack = ["slack-bolt==1.27.0", "slack-sdk==3.40.1", "aiohttp==3.13.3"]
 matrix = ["mautrix[encryption]==0.21.0", "Markdown==3.10.2", "aiosqlite==0.22.1", "asyncpg==0.31.0", "aiohttp-socks==0.11.0"]

package/tools/lazy_deps.py

@@ -139,10 +139,13 @@ LAZY_DEPS: dict[str, tuple[str, ...]] = {
         "alibabacloud-dingtalk==2.2.42",
         "qrcode==7.4.2",
     ),
-    "platform.feishu": (
-        "lark-oapi==1.5.3",
-        "qrcode==7.4.2",
-    ),
+    "platform.feishu": (
+        "lark-oapi==1.5.3",
+        "qrcode==7.4.2",
+    ),
+    "platform.vk": (
+        "vkbottle==4.6.2",
+    ),
 
     # ─── Terminal backends ─────────────────────────────────────────────────
     "terminal.modal": ("modal==1.3.4",),