Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
from dataclasses import dataclass, field
from typing import Optional
from config.v2_config import (
DEFAULT_AGENT_BACKEND,
DEFAULT_AGENT_IDLE_TIMEOUT_SECONDS,
DEFAULT_OPENCODE_ACTIVE_TURN_TIMEOUT_SECONDS,
DEFAULT_OPENCODE_ERROR_RETRY_LIMIT,
V2Config,
SlackConfig,
DiscordConfig,
TelegramConfig,
LarkConfig,
WeChatConfig,
)
@dataclass
class ClaudeCompatConfig:
enabled: bool
permission_mode: str
cwd: str
system_prompt: Optional[str] = None
cli_path: Optional[str] = None
idle_timeout_seconds: int = DEFAULT_AGENT_IDLE_TIMEOUT_SECONDS
auth_mode: str = "oauth"
api_key: Optional[str] = None
base_url: Optional[str] = None
# Mirrors ``ClaudeConfig.auth_mode_set`` — see the docstring there.
# Defaults to ``False`` so legacy installs that never saved through
# the Settings UI keep their inherited ``ANTHROPIC_*`` env-var auth.
auth_mode_set: bool = False
def __post_init__(self) -> None:
self.permission_mode = str(self.permission_mode)
self.cwd = str(self.cwd)
if self.cli_path is not None:
self.cli_path = str(self.cli_path)
@dataclass
class CodexCompatConfig:
enabled: bool
binary: str
extra_args: list[str]
idle_timeout_seconds: int = DEFAULT_AGENT_IDLE_TIMEOUT_SECONDS
auth_mode: str = "oauth"
@dataclass
class OpenCodeCompatConfig:
enabled: bool
binary: str
request_timeout_seconds: int
default_reasoning_effort: Optional[str] = None
error_retry_limit: int = DEFAULT_OPENCODE_ERROR_RETRY_LIMIT # Max retries on LLM stream errors (0 = no retry)
active_turn_timeout_seconds: int = DEFAULT_OPENCODE_ACTIVE_TURN_TIMEOUT_SECONDS
# User's saved default provider from Settings → Backends → OpenCode.
# Used as the ``providerID`` when a routed model string has no ``provider/``
# prefix (most agents.opencode model entries are bare model IDs).
default_provider: Optional[str] = None
@dataclass
class AppCompatConfig:
platform: str
slack: SlackConfig
claude: ClaudeCompatConfig
log_level: str
ack_mode: str
language: str
default_cwd: str
platforms: dict = field(default_factory=lambda: {"enabled": ["slack"], "primary": "slack"})
discord: Optional[DiscordConfig] = None
telegram: Optional[TelegramConfig] = None
lark: Optional[LarkConfig] = None
wechat: Optional[WeChatConfig] = None
codex: Optional[CodexCompatConfig] = None
opencode: Optional[OpenCodeCompatConfig] = None
show_duration: bool = False
include_time_info: bool = True
include_user_info: bool = True
reply_enhancements: bool = True
default_backend: str = DEFAULT_AGENT_BACKEND
resource_governance: dict = field(default_factory=lambda: {"mode": "auto"})
# Mirrors ``V2Config.runtime.harness_prompt_echo``; read on the IM turn path, so
# it has to reach the controller's runtime config like ``resource_governance``.
harness_prompt_echo: bool = True
def enabled_platforms(self) -> list[str]:
enabled = self.platforms.get("enabled") if isinstance(self.platforms, dict) else None
# An explicit empty list is the workbench-only signal: no external IM
# platform is enabled and the in-process Avibe surface is wired by the
# controller (never by the IM factory, which has no AppCompatConfig for
# "avibe"). Mirror ``V2Config.enabled_platforms`` and return ``[]`` so
# ``create_clients`` produces no clients. Fall back to ``[self.platform]``
# only for legacy configs that never populated ``enabled`` at all.
if isinstance(enabled, list):
return [str(platform) for platform in enabled]
return [self.platform]
def runtime_agent_cli_path(
configured: str | None,
default: str,
*,
resolve_agent_paths: bool,
) -> str:
"""Project one saved selector to the executable used by desktop Runtime."""
selected = str(configured).strip() if configured is not None else default
selected = selected or default
from vibe.upgrade import is_desktop_managed_runtime
if not resolve_agent_paths or not is_desktop_managed_runtime():
return selected
# GUI-launched processes do not inherit the user's shell PATH. Use the same
# resolver as Settings so "installed" and the executable actually launched
# by Claude, Codex, or OpenCode can never disagree.
from vibe.cli_paths import resolve_cli_path
# ``include_npm_global`` is the only branch of the resolver that spawns a
# process: it shells out to ``npm config get prefix`` with a five-second
# timeout, uncached, and only when the CLI was not found by any cheap means.
# ``to_app_config`` is reached from async request paths, so that call would
# block an event loop for up to five seconds per missing backend. The cheap
# candidates it keeps -- ~/.local/bin, ~/.bun/bin, Homebrew, /usr/local/bin
# and every NVM version -- already cover what a GUI-launched Runtime needs.
return resolve_cli_path(selected, include_npm_global=False) or selected
def to_app_config(
v2: V2Config,
*,
resolve_agent_paths: bool = True,
) -> AppCompatConfig:
claude = ClaudeCompatConfig(
enabled=v2.agents.claude.enabled,
permission_mode="bypassPermissions",
cwd=v2.runtime.default_cwd,
system_prompt=None,
cli_path=runtime_agent_cli_path(
v2.agents.claude.cli_path,
"claude",
resolve_agent_paths=resolve_agent_paths,
),
idle_timeout_seconds=v2.agents.claude.idle_timeout_seconds,
# Forward V2Config auth fields so ``session_handler`` can inject the
# right ``ANTHROPIC_API_KEY`` / ``ANTHROPIC_BASE_URL`` env vars when
# launching the Claude CLI; without this the runtime ignores values
# saved via ``/backend/claude/auth`` and falls back to ambient env.
auth_mode=v2.agents.claude.auth_mode,
api_key=v2.agents.claude.api_key,
base_url=v2.agents.claude.base_url,
auth_mode_set=v2.agents.claude.auth_mode_set,
)
codex = None
if v2.agents.codex.enabled:
codex = CodexCompatConfig(
enabled=True,
binary=runtime_agent_cli_path(
v2.agents.codex.cli_path,
"codex",
resolve_agent_paths=resolve_agent_paths,
),
extra_args=[],
idle_timeout_seconds=v2.agents.codex.idle_timeout_seconds,
auth_mode=v2.agents.codex.auth_mode,
)
opencode = None
if v2.agents.opencode.enabled:
opencode = OpenCodeCompatConfig(
enabled=True,
binary=runtime_agent_cli_path(
v2.agents.opencode.cli_path,
"opencode",
resolve_agent_paths=resolve_agent_paths,
),
request_timeout_seconds=60,
default_reasoning_effort=v2.agents.opencode.default_reasoning_effort,
error_retry_limit=v2.agents.opencode.error_retry_limit,
active_turn_timeout_seconds=v2.agents.opencode.active_turn_timeout_seconds,
# Surface the user's saved provider choice so the OpenCode agent
# adapter can prepend it as ``providerID`` for bare-model strings.
default_provider=v2.agents.opencode.default_provider,
)
slack = SlackConfig(**v2.slack.__dict__)
return AppCompatConfig(
platform=v2.platform,
platforms={
"enabled": v2.platforms.enabled,
"primary": v2.platforms.primary,
},
slack=slack,
discord=v2.discord,
telegram=v2.telegram,
lark=v2.lark,
wechat=v2.wechat,
claude=claude,
codex=codex,
opencode=opencode,
log_level=v2.runtime.log_level,
ack_mode=v2.ack_mode,
language=v2.language,
default_cwd=v2.runtime.default_cwd,
show_duration=v2.show_duration,
include_time_info=v2.include_time_info,
include_user_info=v2.include_user_info,
reply_enhancements=v2.reply_enhancements,
resource_governance=v2.runtime.resource_governance,
harness_prompt_echo=v2.runtime.harness_prompt_echo,
)