openbase-coder 0.1.3__tar.gz → 0.1.5__tar.gz

{openbase_coder-0.1.3 → openbase_coder-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openbase-coder
-Version: 0.1.3
+Version: 0.1.5
 Summary: OpenBase Coder CLI with embedded server
 Project-URL: Repository, https://github.com/openbase-community/openbase-coder
 Project-URL: Issues, https://github.com/openbase-community/openbase-coder/issues

{openbase_coder-0.1.3 → openbase_coder-0.1.5}/openbase_coder_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.3'
-__version_tuple__ = version_tuple = (0, 1, 3)
+__version__ = version = '0.1.5'
+__version_tuple__ = version_tuple = (0, 1, 5)
 
 __commit_id__ = commit_id = None

openbase_coder-0.1.5/openbase_coder_cli/brain_score.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def brain_score_token_file() -> Path:
+    return Path(
+        os.getenv(
+            "OPENBASE_BRAIN_SCORE_TOKEN_FILE",
+            str(Path.home() / ".openbase" / "brain_score_token"),
+        )
+    ).expanduser()
+
+
+def load_brain_score_token() -> str:
+    configured = os.getenv("OPENBASE_BRAIN_SCORE_TOKEN", "").strip()
+    if configured:
+        return configured
+    try:
+        return brain_score_token_file().read_text(encoding="utf-8").strip()
+    except (FileNotFoundError, OSError):
+        return ""
+
+
+def brain_score_token_configured() -> bool:
+    return bool(load_brain_score_token())

{openbase_coder-0.1.3 → openbase_coder-0.1.5}/openbase_coder_cli/cartesia_voice_catalog.py

@@ -96,6 +96,12 @@ CARTESIA_VOICE_CATALOG: tuple[CartesiaVoiceCatalogEntry, ...] = (
     CartesiaVoiceCatalogEntry("91b4cf29-5166-44eb-8054-30d40ecc8081", "Tina", "en", "US", "feminine"),
 )
 
+DEFAULT_SUPER_AGENT_VOICE_IDS = tuple(
+    voice.id
+    for voice in CARTESIA_VOICE_CATALOG
+    if voice.id != "9626c31c-bec5-4cca-baa8-f8ba9e84c8bc"
+)
+
 _CATALOG_BY_ID = {voice.id: voice for voice in CARTESIA_VOICE_CATALOG}
 _CATALOG_BY_NORMALIZED_NAME = {
     " ".join(voice.name.casefold().split()): voice for voice in CARTESIA_VOICE_CATALOG

{openbase_coder-0.1.3 → openbase_coder-0.1.5}/openbase_coder_cli/cli/node.py

@@ -24,6 +24,7 @@ def run_workspace_package_command(workspace_dir: Path, package_dir: Path, *args:
     subprocess.run(
         [executable, *command_prefix, *command_args],
         cwd=str(package_dir),
+        env=_package_manager_env(executable, command_args),
         check=True,
     )
     return True
@@ -93,12 +94,22 @@ def _normalize_package_manager_args(
     workspace_dir: Path,
     args: tuple[str, ...],
 ) -> tuple[str, ...]:
-    """Keep managed workspace installs reproducible when using pnpm."""
+    """Avoid mutating or validating partial install-set lockfiles with pnpm."""
     if (
         Path(executable).name == "pnpm"
         and args == ("install",)
         and (workspace_dir / "pnpm-lock.yaml").is_file()
     ):
-        return ("install", "--frozen-lockfile")
+        return ("install", "--no-lockfile", "--shamefully-hoist")
 
     return args
+
+
+def _package_manager_env(
+    executable: str,
+    args: tuple[str, ...],
+) -> dict[str, str] | None:
+    if Path(executable).name == "pnpm" and args and args[0] == "install":
+        return {**os.environ, "CI": "true"}
+
+    return None

{openbase_coder-0.1.3 → openbase_coder-0.1.5}/openbase_coder_cli/cli/setup.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import platform
 import secrets
 import shlex
@@ -14,6 +15,7 @@ from openbase_coder_cli.cli.node import run_workspace_package_command
 from openbase_coder_cli.paths import (
     CODEX_AGENTS_MD_PATH,
     CODEX_DIRECT_LIVEKIT_INSTRUCTIONS_PATH,
+    CODEX_DISPATCHER_CONFIG_PATH,
     CODEX_DISPATCHER_INSTRUCTIONS_PATH,
     CODEX_HOME_DIR,
     CODEX_SUPER_AGENT_INSTRUCTIONS_PATH,
@@ -34,6 +36,21 @@ CODEX_HOME_DEFAULT_FILES = (
     ("DISPATCHER_INSTRUCTIONS.md", CODEX_DISPATCHER_INSTRUCTIONS_PATH),
     ("SUPER_AGENT_INSTRUCTIONS.md", CODEX_SUPER_AGENT_INSTRUCTIONS_PATH),
 )
+SUPER_AGENTS_MCP_TABLE = "mcp_servers.super-agents"
+SUPER_AGENTS_MCP_COMMAND = "super-agents-mcp"
+CODEX_HOME_PERMISSION_VALUES = (
+    ("sandbox_mode", json.dumps("danger-full-access")),
+    (
+        "approval_policy",
+        "{ granular = { sandbox_approval = false, rules = false, "
+        "mcp_elicitations = false, request_permissions = false, "
+        "skill_approval = false } }",
+    ),
+)
+CODEX_HOME_DEFAULT_DISPATCHER_CONFIG = {
+    "dispatcher_reasoning_effort": "low",
+    "super_agents_reasoning_effort": "high",
+}
 
 
 @click.command()
@@ -109,11 +126,15 @@ def setup(
     # --- Symlink Codex auth into the service CODEX_HOME ---
     _symlink_codex_auth()
     _ensure_codex_home_default_files(workspace_dir)
+    _ensure_codex_home_dispatcher_config()
     _symlink_codex_home_skills(workspace_dir)
 
     # --- Initialize CLI workspace ---
     _init_cli_workspace(workspace_dir)
 
+    # --- Configure the service CODEX_HOME ---
+    _ensure_codex_home_config(workspace_dir)
+
     # --- Install/update user-facing CLI shim ---
     _install_cli_shim(workspace_dir)
 
@@ -142,7 +163,9 @@ def _clone_workspace(workspace_dir: str) -> None:
     if ws.exists() and (ws / ".git").is_dir():
         click.echo(f"Workspace already exists at {ws}, pulling latest...")
         _update_existing_workspace(ws)
+        _remove_managed_repo_symlinks(ws)
         _multi_sync(ws)
+        _update_install_set_repos(ws)
         return
 
     click.echo(f"Cloning workspace to {ws}...")
@@ -151,6 +174,7 @@ def _clone_workspace(workspace_dir: str) -> None:
         check=True,
     )
     _multi_sync(ws)
+    _update_install_set_repos(ws)
 
 
 def _update_existing_workspace(ws: Path) -> None:
@@ -176,6 +200,57 @@ def _update_existing_workspace(ws: Path) -> None:
     subprocess.run(["git", "-C", str(ws), "pull", "--ff-only"], check=True)
 
 
+def _remove_managed_repo_symlinks(ws: Path) -> None:
+    if ws.resolve() != DEFAULT_WORKSPACE_DIR.resolve():
+        return
+
+    for repo_name in _install_set_repo_names(ws):
+        repo_path = ws / repo_name
+        if repo_path.is_symlink():
+            click.echo(f"Removing symlinked install repo at {repo_path}")
+            repo_path.unlink()
+
+
+def _update_install_set_repos(ws: Path) -> None:
+    for repo_name in _install_set_repo_names(ws):
+        repo_path = ws / repo_name
+        if not (repo_path / ".git").exists():
+            continue
+
+        if ws.resolve() == DEFAULT_WORKSPACE_DIR.resolve():
+            click.echo(f"Updating managed install repo {repo_name}...")
+            subprocess.run(
+                ["git", "-C", str(repo_path), "fetch", "origin", "main"],
+                check=True,
+            )
+            subprocess.run(
+                ["git", "-C", str(repo_path), "reset", "--hard", "origin/main"],
+                check=True,
+            )
+        else:
+            subprocess.run(["git", "-C", str(repo_path), "pull", "--ff-only"], check=True)
+
+
+def _install_set_repo_names(ws: Path) -> list[str]:
+    multi_json_path = ws / "multi.json"
+    if not multi_json_path.is_file():
+        return []
+
+    try:
+        multi_json = json.loads(multi_json_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return []
+
+    names = []
+    for repo in multi_json.get("repos", []):
+        install_sets = repo.get("installSets")
+        if install_sets is not None and WORKSPACE_INSTALL_SET not in install_sets:
+            continue
+        if name := repo.get("name"):
+            names.append(name)
+    return names
+
+
 def _multi_sync(ws_path: Path) -> None:
     click.echo(f"Running multi sync --install-set {WORKSPACE_INSTALL_SET}...")
     sync_workspace(ws_path, install_set=WORKSPACE_INSTALL_SET)
@@ -255,6 +330,23 @@ def _ensure_codex_home_default_files(workspace_dir: str) -> None:
         click.echo(f"Created Codex home default at {target_path}")
 
 
+def _ensure_codex_home_dispatcher_config() -> None:
+    """Create the missing Openbase dispatcher config."""
+    if CODEX_DISPATCHER_CONFIG_PATH.exists():
+        click.echo(
+            f"Codex home dispatcher config already exists at "
+            f"{CODEX_DISPATCHER_CONFIG_PATH}"
+        )
+        return
+
+    CODEX_DISPATCHER_CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    CODEX_DISPATCHER_CONFIG_PATH.write_text(
+        json.dumps(CODEX_HOME_DEFAULT_DISPATCHER_CONFIG, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    click.echo(f"Created Codex home dispatcher config at {CODEX_DISPATCHER_CONFIG_PATH}")
+
+
 def _symlink_codex_home_skills(workspace_dir: str) -> None:
     """Symlink workspace-owned skills into the Openbase Codex home."""
     source_root = Path(workspace_dir) / CODEX_HOME_SKILLS_SOURCE_DIR
@@ -284,6 +376,141 @@ def _symlink_codex_home_skills(workspace_dir: str) -> None:
         click.echo(f"Linked Codex home skill {target_path} → {source_path}")
 
 
+def _ensure_codex_home_config(workspace_dir: str) -> None:
+    """Configure Openbase's service Codex home."""
+    CODEX_HOME_DIR.mkdir(parents=True, exist_ok=True)
+    config_path = CODEX_HOME_DIR / "config.toml"
+    command_path, args = _super_agents_mcp_command(Path(workspace_dir))
+    block = (
+        f"[{SUPER_AGENTS_MCP_TABLE}]\n"
+        f"command = {json.dumps(str(command_path))}\n"
+        f"{_toml_args_line(args)}"
+    )
+
+    if not command_path.is_file():
+        click.echo(
+            f"Super Agents MCP command not found at {command_path}; "
+            "writing the expected config path anyway."
+        )
+
+    existing = ""
+    if config_path.is_file():
+        existing = config_path.read_text(encoding="utf-8")
+
+    updated = _ensure_toml_root_values(existing, CODEX_HOME_PERMISSION_VALUES)
+    updated = _replace_toml_table(updated, SUPER_AGENTS_MCP_TABLE, block)
+    if updated == existing:
+        click.echo(f"Codex home config already configured at {config_path}")
+        return
+
+    config_path.write_text(updated, encoding="utf-8")
+    click.echo(f"Configured Codex home config at {config_path}")
+
+
+def _super_agents_mcp_command(workspace_dir: Path) -> tuple[Path, list[str]]:
+    candidates = (
+        workspace_dir / ".venv" / "bin" / SUPER_AGENTS_MCP_COMMAND,
+        workspace_dir / "cli" / ".venv" / "bin" / SUPER_AGENTS_MCP_COMMAND,
+    )
+    for candidate in candidates:
+        if candidate.is_file():
+            return candidate, []
+
+    if command := which(SUPER_AGENTS_MCP_COMMAND):
+        return Path(command), []
+
+    if uv_bin := which("uv"):
+        run_dir = workspace_dir / "cli"
+        if not run_dir.is_dir():
+            run_dir = workspace_dir
+        return Path(uv_bin), [
+            "--directory",
+            str(run_dir),
+            "run",
+            SUPER_AGENTS_MCP_COMMAND,
+        ]
+
+    return candidates[0], []
+
+
+def _toml_args_line(args: list[str]) -> str:
+    if not args:
+        return ""
+    return f"args = {json.dumps(args)}\n"
+
+
+def _ensure_toml_root_values(
+    text: str,
+    values: tuple[tuple[str, str], ...],
+) -> str:
+    lines = text.splitlines()
+    first_table_index = next(
+        (
+            index
+            for index, line in enumerate(lines)
+            if line.strip().startswith("[") and line.strip().endswith("]")
+        ),
+        len(lines),
+    )
+    root_lines = lines[:first_table_index]
+    table_lines = lines[first_table_index:]
+    keys = {key for key, _value in values}
+    updated_root = [
+        line
+        for line in root_lines
+        if _toml_root_key(line) not in keys
+    ]
+
+    while updated_root and not updated_root[-1].strip():
+        updated_root.pop()
+
+    for key, value in values:
+        updated_root.append(f"{key} = {value}")
+
+    while table_lines and not table_lines[0].strip():
+        table_lines.pop(0)
+
+    if table_lines:
+        return "\n".join(updated_root) + "\n\n" + "\n".join(table_lines) + "\n"
+    return "\n".join(updated_root) + "\n"
+
+
+def _toml_root_key(line: str) -> str | None:
+    stripped = line.strip()
+    if not stripped or stripped.startswith("#") or "=" not in stripped:
+        return None
+    return stripped.split("=", 1)[0].strip()
+
+
+def _replace_toml_table(text: str, table_name: str, block: str) -> str:
+    target_header = f"[{table_name}]"
+    lines = text.splitlines()
+    output: list[str] = []
+    index = 0
+
+    while index < len(lines):
+        if lines[index].strip() == target_header:
+            index += 1
+            while index < len(lines):
+                stripped = lines[index].strip()
+                if stripped.startswith("[") and stripped.endswith("]"):
+                    break
+                index += 1
+            while output and not output[-1].strip():
+                output.pop()
+            continue
+
+        output.append(lines[index])
+        index += 1
+
+    while output and not output[-1].strip():
+        output.pop()
+
+    if output:
+        return "\n".join(output) + "\n\n" + block
+    return block
+
+
 def _workspace_skill_sources(source_root: Path) -> list[Path]:
     candidate_roots = [source_root / "skills", source_root]
     seen: set[Path] = set()
@@ -419,8 +646,6 @@ def _ensure_env_file(
         "LIVEKIT_CODEX_THREAD_CWD=~",
         "# Cartesia voice used by the LiveKit agent TTS.",
         "CARTESIA_VOICE_ID=9626c31c-bec5-4cca-baa8-f8ba9e84c8bc",
-        "# Optional comma-separated voices for direct thread routing: voice-id:Display Name.",
-        "# CARTESIA_SUPER_AGENT_VOICES=f786b574-daa5-4673-aa0c-cbe3e8534c02:Alice",
         "OPENBASE_CODER_CLI_OAUTH_CLIENT_ID=openbase-coder-cli",
     ]
 

{openbase_coder-0.1.3 → openbase_coder-0.1.5}/openbase_coder_cli/livekit_agent/livekit.py

@@ -42,6 +42,15 @@ from livekit.agents.types import DEFAULT_API_CONNECT_OPTIONS, NOT_GIVEN
 from livekit.plugins import assemblyai, cartesia, deepgram, silero
 from livekit.plugins.turn_detector.multilingual import MultilingualModel
 
+from openbase_coder_cli.brain_score import (
+    brain_score_token_configured,
+    brain_score_token_file,
+    load_brain_score_token,
+)
+from openbase_coder_cli.cartesia_voice_catalog import (
+    DEFAULT_SUPER_AGENT_VOICE_IDS,
+    cartesia_voice_for_id,
+)
 from openbase_coder_cli.dispatcher_config import dispatcher_voice
 from openbase_coder_cli.livekit_agent.codex_app_client import CodexAppServerClient
 from openbase_coder_cli.livekit_agent.speech_formatter import format_for_speech
@@ -165,12 +174,7 @@ BRAIN_SCORE_OUTPUT_PATH = Path(
         str(Path.home() / ".openbase" / "brain_score.json"),
     )
 ).expanduser()
-BRAIN_SCORE_TOKEN_FILE = Path(
-    os.getenv(
-        "OPENBASE_BRAIN_SCORE_TOKEN_FILE",
-        str(Path.home() / ".openbase" / "brain_score_token"),
-    )
-).expanduser()
+BRAIN_SCORE_TOKEN_FILE = brain_score_token_file()
 BRAIN_SCORE_LATITUDE = os.getenv("OPENBASE_BRAIN_SCORE_LATITUDE", "").strip()
 BRAIN_SCORE_LONGITUDE = os.getenv("OPENBASE_BRAIN_SCORE_LONGITUDE", "").strip()
 
@@ -181,27 +185,6 @@ class CartesiaVoice:
     name: str
 
 
-def _super_agent_voices(env: Mapping[str, str]) -> tuple[CartesiaVoice, ...]:
-    named_configured = env.get("CARTESIA_SUPER_AGENT_VOICES")
-    if named_configured is not None:
-        return _parse_voices(named_configured)
-
-    configured = env.get("CARTESIA_SUPER_AGENT_VOICE_IDS")
-    if configured is not None:
-        return _voices_from_ids(_parse_voice_ids(configured))
-
-    dispatcher_voice_id = env.get("CARTESIA_VOICE_ID", DEFAULT_CARTESIA_VOICE_ID)
-    announcer_voice_id = env.get(
-        "CARTESIA_ANNOUNCER_VOICE_ID",
-        DEFAULT_CARTESIA_ANNOUNCER_VOICE_ID,
-    )
-    return _voices_from_ids(
-        voice_id
-        for voice_id in (announcer_voice_id,)
-        if voice_id and voice_id != dispatcher_voice_id
-    )
-
-
 def dispatcher_voice_config(
     *,
     config_path: str | Path | None = None,
@@ -212,49 +195,27 @@ def dispatcher_voice_config(
     return CartesiaVoice(voice_id=configured["id"], name=configured["name"])
 
 
-def _parse_voice_ids(value: str) -> tuple[str, ...]:
-    return tuple(
-        voice_id for voice_id in (part.strip() for part in value.split(",")) if voice_id
-    )
-
-
-def _parse_voices(value: str) -> tuple[CartesiaVoice, ...]:
-    voices: list[CartesiaVoice] = []
-    for part in (part.strip() for part in value.split(",")):
-        if not part:
-            continue
-        voice_id, separator, name = part.partition(":")
-        trimmed_voice_id = voice_id.strip()
-        if not trimmed_voice_id:
-            continue
-        trimmed_name = name.strip() if separator else ""
-        voices.append(
-            CartesiaVoice(
-                voice_id=trimmed_voice_id,
-                name=trimmed_name or f"Voice {len(voices) + 1}",
-            )
-        )
-    return tuple(voices)
-
-
 def _voices_from_ids(voice_ids) -> tuple[CartesiaVoice, ...]:
     return tuple(
-        CartesiaVoice(voice_id=voice_id, name=f"Voice {index + 1}")
+        CartesiaVoice(
+            voice_id=voice_id,
+            name=cartesia_voice_for_id(voice_id).name
+            if cartesia_voice_for_id(voice_id)
+            else f"Voice {index + 1}",
+        )
         for index, voice_id in enumerate(voice_ids)
     )
 
 
-CARTESIA_SUPER_AGENT_VOICES = _super_agent_voices(os.environ)
-CARTESIA_SUPER_AGENT_VOICE_IDS = tuple(
-    voice.voice_id for voice in CARTESIA_SUPER_AGENT_VOICES
-)
+SUPER_AGENT_VOICE_IDS = DEFAULT_SUPER_AGENT_VOICE_IDS
+SUPER_AGENT_VOICES = _voices_from_ids(SUPER_AGENT_VOICE_IDS)
 
 
 def _current_super_agent_voices() -> tuple[CartesiaVoice, ...]:
-    voice_ids = tuple(voice.voice_id for voice in CARTESIA_SUPER_AGENT_VOICES)
-    if voice_ids == tuple(CARTESIA_SUPER_AGENT_VOICE_IDS):
-        return CARTESIA_SUPER_AGENT_VOICES
-    return _voices_from_ids(CARTESIA_SUPER_AGENT_VOICE_IDS)
+    voice_ids = tuple(voice.voice_id for voice in SUPER_AGENT_VOICES)
+    if voice_ids == tuple(SUPER_AGENT_VOICE_IDS):
+        return SUPER_AGENT_VOICES
+    return _voices_from_ids(SUPER_AGENT_VOICE_IDS)
 
 
 def _normalize_spoken_command(text: str) -> str:
@@ -507,20 +468,11 @@ def _event_text_hash(text: str) -> str:
 
 
 def _load_brain_score_token() -> str:
-    configured = os.getenv("OPENBASE_BRAIN_SCORE_TOKEN", "").strip()
-    if configured:
-        return configured
-    try:
-        return BRAIN_SCORE_TOKEN_FILE.read_text(encoding="utf-8").strip()
-    except FileNotFoundError:
-        return ""
-    except OSError:
-        logger.warning(
-            "Unable to read brain score token file %s",
-            BRAIN_SCORE_TOKEN_FILE,
-            exc_info=True,
-        )
-        return ""
+    return load_brain_score_token()
+
+
+def _brain_score_enabled() -> bool:
+    return BRAIN_SCORE_ENABLED and brain_score_token_configured()
 
 
 class BrainScoreSTT(livekit_stt.STT):
@@ -2559,12 +2511,12 @@ def _build_stt():
     if LIVEKIT_STT_PROVIDER == "deepgram":
         logger.info("Using Deepgram STT")
         stt = deepgram.STT(api_key=DEEPGRAM_API_KEY)
-        stt = BrainScoreSTT(stt) if BRAIN_SCORE_ENABLED else stt
+        stt = BrainScoreSTT(stt) if _brain_score_enabled() else stt
         return LoggingSTT(stt) if LIVEKIT_VERBOSE_LOGGING else stt
     if LIVEKIT_STT_PROVIDER == "assemblyai":
         logger.info("Using AssemblyAI STT")
         stt = assemblyai.STT(api_key=ASSEMBLY_AI_API_KEY)
-        stt = BrainScoreSTT(stt) if BRAIN_SCORE_ENABLED else stt
+        stt = BrainScoreSTT(stt) if _brain_score_enabled() else stt
         return LoggingSTT(stt) if LIVEKIT_VERBOSE_LOGGING else stt
 
     raise ValueError(f"Unsupported LIVEKIT_STT_PROVIDER={LIVEKIT_STT_PROVIDER!r}")

{openbase_coder-0.1.3 → openbase_coder-0.1.5}/openbase_coder_cli/livekit_voice_route.py

@@ -6,13 +6,13 @@ import json
 import os
 import time
 import uuid
-from collections.abc import Mapping
 from dataclasses import asdict, dataclass
 from pathlib import Path
 
 import livekit.api as livekit_api
 
 from openbase_coder_cli.cartesia_voice_catalog import (
+    DEFAULT_SUPER_AGENT_VOICE_IDS,
     cartesia_voice_for_id,
     cartesia_voice_for_name,
 )
@@ -120,52 +120,6 @@ def instruction_override_supported() -> bool:
     return True
 
 
-def _super_agent_voices(env: Mapping[str, str]) -> tuple[CartesiaVoice, ...]:
-    named_configured = env.get("CARTESIA_SUPER_AGENT_VOICES")
-    if named_configured is not None:
-        return _parse_voices(named_configured)
-
-    configured = env.get("CARTESIA_SUPER_AGENT_VOICE_IDS")
-    if configured is not None:
-        return _voices_from_ids(_parse_voice_ids(configured))
-
-    dispatcher_voice_id = env.get("CARTESIA_VOICE_ID", DEFAULT_CARTESIA_VOICE_ID)
-    announcer_voice_id = env.get(
-        "CARTESIA_ANNOUNCER_VOICE_ID",
-        DEFAULT_CARTESIA_ANNOUNCER_VOICE_ID,
-    )
-    return _voices_from_ids(
-        voice_id
-        for voice_id in (announcer_voice_id,)
-        if voice_id and voice_id != dispatcher_voice_id
-    )
-
-
-def _parse_voice_ids(value: str) -> tuple[str, ...]:
-    return tuple(
-        voice_id for voice_id in (part.strip() for part in value.split(",")) if voice_id
-    )
-
-
-def _parse_voices(value: str) -> tuple[CartesiaVoice, ...]:
-    voices: list[CartesiaVoice] = []
-    for part in (part.strip() for part in value.split(",")):
-        if not part:
-            continue
-        voice_id, separator, name = part.partition(":")
-        trimmed_voice_id = voice_id.strip()
-        if not trimmed_voice_id:
-            continue
-        trimmed_name = name.strip() if separator else ""
-        voices.append(
-            CartesiaVoice(
-                voice_id=trimmed_voice_id,
-                name=trimmed_name or f"Voice {len(voices) + 1}",
-            )
-        )
-    return tuple(voices)
-
-
 def _voices_from_ids(voice_ids) -> tuple[CartesiaVoice, ...]:
     return tuple(
         CartesiaVoice(
@@ -178,17 +132,15 @@ def _voices_from_ids(voice_ids) -> tuple[CartesiaVoice, ...]:
     )
 
 
-CARTESIA_SUPER_AGENT_VOICES = _super_agent_voices(os.environ)
-CARTESIA_SUPER_AGENT_VOICE_IDS = tuple(
-    voice.voice_id for voice in CARTESIA_SUPER_AGENT_VOICES
-)
+SUPER_AGENT_VOICE_IDS = DEFAULT_SUPER_AGENT_VOICE_IDS
+SUPER_AGENT_VOICES = _voices_from_ids(SUPER_AGENT_VOICE_IDS)
 
 
 def _current_super_agent_voices() -> tuple[CartesiaVoice, ...]:
-    voice_ids = tuple(voice.voice_id for voice in CARTESIA_SUPER_AGENT_VOICES)
-    if voice_ids == tuple(CARTESIA_SUPER_AGENT_VOICE_IDS):
-        return CARTESIA_SUPER_AGENT_VOICES
-    return _voices_from_ids(CARTESIA_SUPER_AGENT_VOICE_IDS)
+    voice_ids = tuple(voice.voice_id for voice in SUPER_AGENT_VOICES)
+    if voice_ids == tuple(SUPER_AGENT_VOICE_IDS):
+        return SUPER_AGENT_VOICES
+    return _voices_from_ids(SUPER_AGENT_VOICE_IDS)
 
 
 def stable_super_agent_voice(

{openbase_coder-0.1.3 → openbase_coder-0.1.5}/openbase_coder_cli/openbase_coder_cli_app/brain_readiness.py

@@ -9,6 +9,8 @@ from typing import Any
 from rest_framework.decorators import api_view
 from rest_framework.response import Response
 
+from openbase_coder_cli.brain_score import brain_score_token_configured
+
 
 def default_brain_score_output_path() -> Path:
     return Path(
@@ -54,19 +56,27 @@ def _read_brain_score_file(path: Path) -> dict[str, Any] | None:
     return payload
 
 
+def _unavailable_response(*, disabled_reason: str | None = None) -> dict[str, Any]:
+    return {
+        "available": False,
+        "brain_readiness_score": None,
+        "brs": None,
+        "parallel_voice_threshold": None,
+        "updated_at": None,
+        "computed_at": None,
+        "chunk_index": None,
+        "age_seconds": None,
+        "disabled_reason": disabled_reason,
+    }
+
+
 def build_brain_readiness_response(path: Path | None = None) -> dict[str, Any]:
+    if not brain_score_token_configured():
+        return _unavailable_response(disabled_reason="missing_token")
+
     payload = _read_brain_score_file(path or default_brain_score_output_path())
     if payload is None:
-        return {
-            "available": False,
-            "brain_readiness_score": None,
-            "brs": None,
-            "parallel_voice_threshold": None,
-            "updated_at": None,
-            "computed_at": None,
-            "chunk_index": None,
-            "age_seconds": None,
-        }
+        return _unavailable_response()
 
     score = _coerce_score(payload.get("brs"))
     updated_at = payload.get("updated_at")
@@ -83,6 +93,7 @@ def build_brain_readiness_response(path: Path | None = None) -> dict[str, Any]:
         "computed_at": payload.get("computed_at"),
         "chunk_index": payload.get("chunk_index"),
         "age_seconds": age_seconds,
+        "disabled_reason": None,
     }