devcopilot 0.2.0__py3-none-any.whl

config/settings.py

@@ -0,0 +1,538 @@
+"""Centralized configuration using Pydantic Settings."""
+
+import os
+from collections.abc import Mapping
+from dataclasses import dataclass
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+from dotenv import dotenv_values
+from pydantic import Field, field_validator, model_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from .constants import HTTP_CONNECT_TIMEOUT_DEFAULT
+from .nim import NimSettings
+from .paths import default_claude_workspace_path, managed_env_path
+from .provider_ids import SUPPORTED_PROVIDER_IDS
+
+
+@dataclass(frozen=True, slots=True)
+class ConfiguredChatModelRef:
+    """A unique configured chat model reference and the env keys that set it."""
+
+    model_ref: str
+    provider_id: str
+    model_id: str
+    sources: tuple[str, ...]
+
+
+def _env_files() -> tuple[Path, ...]:
+    """Return env file paths in priority order (later overrides earlier)."""
+    files: list[Path] = [
+        Path(".env"),
+        managed_env_path(),
+    ]
+    if explicit := os.environ.get("FCC_ENV_FILE"):
+        files.append(Path(explicit))
+    return tuple(files)
+
+
+def _configured_env_files(model_config: Mapping[str, Any]) -> tuple[Path, ...]:
+    """Return the currently configured env files for Settings."""
+    configured = model_config.get("env_file")
+    if configured is None:
+        return ()
+    if isinstance(configured, (str, Path)):
+        return (Path(configured),)
+    return tuple(Path(item) for item in configured)
+
+
+def _env_file_value(path: Path, key: str) -> str | None:
+    """Return a dotenv value when the file explicitly defines the key."""
+    if not path.is_file():
+        return None
+
+    try:
+        values = dotenv_values(path)
+    except OSError:
+        return None
+
+    if key not in values:
+        return None
+    value = values[key]
+    return "" if value is None else value
+
+
+def _env_file_override(model_config: Mapping[str, Any], key: str) -> str | None:
+    """Return the last configured dotenv value that explicitly defines a key."""
+    configured_value: str | None = None
+    for env_file in _configured_env_files(model_config):
+        value = _env_file_value(env_file, key)
+        if value is not None:
+            configured_value = value
+    return configured_value
+
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables."""
+
+    # ==================== OpenRouter Config ====================
+    open_router_api_key: str = Field(default="", validation_alias="OPENROUTER_API_KEY")
+
+    # ==================== Mistral La Plateforme ====================
+    mistral_api_key: str = Field(default="", validation_alias="MISTRAL_API_KEY")
+
+    # ==================== Mistral Codestral (codestral.mistral.ai) ====================
+    codestral_api_key: str = Field(default="", validation_alias="CODESTRAL_API_KEY")
+
+    # ==================== DeepSeek Config ====================
+    deepseek_api_key: str = Field(default="", validation_alias="DEEPSEEK_API_KEY")
+
+    # ==================== Kimi Config ====================
+    kimi_api_key: str = Field(default="", validation_alias="KIMI_API_KEY")
+
+    # ==================== Wafer Config ====================
+    wafer_api_key: str = Field(default="", validation_alias="WAFER_API_KEY")
+
+    # ==================== OpenCode Zen / OpenCode Go ====================
+    # Same key from opencode.ai/auth; zen uses prefix ``opencode/``, Go uses ``opencode_go/``.
+    opencode_api_key: str = Field(default="", validation_alias="OPENCODE_API_KEY")
+
+    # ==================== Z.ai Config ====================
+    zai_api_key: str = Field(default="", validation_alias="ZAI_API_KEY")
+
+    # ==================== Fireworks AI Config ====================
+    fireworks_api_key: str = Field(default="", validation_alias="FIREWORKS_API_KEY")
+
+    # ==================== Google Gemini (Google AI Studio) ====================
+    gemini_api_key: str = Field(default="", validation_alias="GEMINI_API_KEY")
+
+    # ==================== Groq (OpenAI-compatible) ====================
+    groq_api_key: str = Field(default="", validation_alias="GROQ_API_KEY")
+
+    # ==================== Cerebras Inference (OpenAI-compatible) ====================
+    cerebras_api_key: str = Field(default="", validation_alias="CEREBRAS_API_KEY")
+
+    # ==================== Messaging Platform Selection ====================
+    # Valid: "telegram" | "discord" | "none"
+    messaging_platform: str = Field(
+        default="discord", validation_alias="MESSAGING_PLATFORM"
+    )
+    messaging_rate_limit: int = Field(
+        default=1, validation_alias="MESSAGING_RATE_LIMIT"
+    )
+    messaging_rate_window: float = Field(
+        default=1.0, validation_alias="MESSAGING_RATE_WINDOW"
+    )
+
+    # ==================== NVIDIA NIM Config ====================
+    nvidia_nim_api_key: str = ""
+
+    # ==================== LM Studio Config ====================
+    lm_studio_base_url: str = Field(
+        default="http://localhost:1234/v1",
+        validation_alias="LM_STUDIO_BASE_URL",
+    )
+
+    # ==================== Llama.cpp Config ====================
+    llamacpp_base_url: str = Field(
+        default="http://localhost:8080/v1",
+        validation_alias="LLAMACPP_BASE_URL",
+    )
+
+    # ==================== Ollama Config ====================
+    ollama_base_url: str = Field(
+        default="http://localhost:11434",
+        validation_alias="OLLAMA_BASE_URL",
+    )
+
+    # ==================== Model ====================
+    # All Claude model requests are mapped to this single model (fallback)
+    # Format: provider_type/model/name
+    model: str = "nvidia_nim/nvidia/nemotron-3-super-120b-a12b"
+
+    # Per-model overrides (optional, falls back to MODEL)
+    # Each can use a different provider
+    model_opus: str | None = Field(default=None, validation_alias="MODEL_OPUS")
+    model_sonnet: str | None = Field(default=None, validation_alias="MODEL_SONNET")
+    model_haiku: str | None = Field(default=None, validation_alias="MODEL_HAIKU")
+
+    # ==================== Per-Provider Proxy ====================
+    nvidia_nim_proxy: str = Field(default="", validation_alias="NVIDIA_NIM_PROXY")
+    open_router_proxy: str = Field(default="", validation_alias="OPENROUTER_PROXY")
+    mistral_proxy: str = Field(default="", validation_alias="MISTRAL_PROXY")
+    codestral_proxy: str = Field(default="", validation_alias="CODESTRAL_PROXY")
+    lmstudio_proxy: str = Field(default="", validation_alias="LMSTUDIO_PROXY")
+    llamacpp_proxy: str = Field(default="", validation_alias="LLAMACPP_PROXY")
+    kimi_proxy: str = Field(default="", validation_alias="KIMI_PROXY")
+    wafer_proxy: str = Field(default="", validation_alias="WAFER_PROXY")
+    opencode_proxy: str = Field(default="", validation_alias="OPENCODE_PROXY")
+    opencode_go_proxy: str = Field(default="", validation_alias="OPENCODE_GO_PROXY")
+    zai_proxy: str = Field(default="", validation_alias="ZAI_PROXY")
+    fireworks_proxy: str = Field(default="", validation_alias="FIREWORKS_PROXY")
+    gemini_proxy: str = Field(default="", validation_alias="GEMINI_PROXY")
+    groq_proxy: str = Field(default="", validation_alias="GROQ_PROXY")
+    cerebras_proxy: str = Field(default="", validation_alias="CEREBRAS_PROXY")
+
+    # ==================== Provider Rate Limiting ====================
+    provider_rate_limit: int = Field(default=40, validation_alias="PROVIDER_RATE_LIMIT")
+    provider_rate_window: int = Field(
+        default=60, validation_alias="PROVIDER_RATE_WINDOW"
+    )
+    provider_max_concurrency: int = Field(
+        default=5, validation_alias="PROVIDER_MAX_CONCURRENCY"
+    )
+    enable_model_thinking: bool = Field(
+        default=True, validation_alias="ENABLE_MODEL_THINKING"
+    )
+    enable_opus_thinking: bool | None = Field(
+        default=None, validation_alias="ENABLE_OPUS_THINKING"
+    )
+    enable_sonnet_thinking: bool | None = Field(
+        default=None, validation_alias="ENABLE_SONNET_THINKING"
+    )
+    enable_haiku_thinking: bool | None = Field(
+        default=None, validation_alias="ENABLE_HAIKU_THINKING"
+    )
+
+    # ==================== HTTP Client Timeouts ====================
+    http_read_timeout: float = Field(
+        default=120.0, validation_alias="HTTP_READ_TIMEOUT"
+    )
+    http_write_timeout: float = Field(
+        default=10.0, validation_alias="HTTP_WRITE_TIMEOUT"
+    )
+    http_connect_timeout: float = Field(
+        default=HTTP_CONNECT_TIMEOUT_DEFAULT,
+        validation_alias="HTTP_CONNECT_TIMEOUT",
+    )
+
+    # ==================== Fast Prefix Detection ====================
+    fast_prefix_detection: bool = True
+
+    # ==================== Optimizations ====================
+    enable_network_probe_mock: bool = True
+    enable_title_generation_skip: bool = True
+    enable_suggestion_mode_skip: bool = True
+    enable_filepath_extraction_mock: bool = True
+
+    # ==================== Local web server tools (web_search / web_fetch) ====================
+    # Off by default: these tools perform outbound HTTP from the proxy (SSRF risk).
+    enable_web_server_tools: bool = Field(
+        default=False, validation_alias="ENABLE_WEB_SERVER_TOOLS"
+    )
+    # Comma-separated URL schemes allowed for web_fetch (default: http,https).
+    web_fetch_allowed_schemes: str = Field(
+        default="http,https", validation_alias="WEB_FETCH_ALLOWED_SCHEMES"
+    )
+    # When true, skip private/loopback/link-local IP blocking for web_fetch (lab only).
+    web_fetch_allow_private_networks: bool = Field(
+        default=False, validation_alias="WEB_FETCH_ALLOW_PRIVATE_NETWORKS"
+    )
+
+    # ==================== Debug / diagnostic logging (avoid sensitive content) ====================
+    # When false (default), API and SSE helpers log only metadata (counts, lengths, ids).
+    log_raw_api_payloads: bool = Field(
+        default=False, validation_alias="LOG_RAW_API_PAYLOADS"
+    )
+    log_raw_sse_events: bool = Field(
+        default=False, validation_alias="LOG_RAW_SSE_EVENTS"
+    )
+    # When false (default), unhandled exceptions log only type + route metadata (no message/traceback).
+    log_api_error_tracebacks: bool = Field(
+        default=False, validation_alias="LOG_API_ERROR_TRACEBACKS"
+    )
+    # When false (default), messaging logs omit text/transcription previews (metadata only).
+    log_raw_messaging_content: bool = Field(
+        default=False, validation_alias="LOG_RAW_MESSAGING_CONTENT"
+    )
+    # When true, log full Claude CLI stderr, non-JSON lines, and parser error text.
+    log_raw_cli_diagnostics: bool = Field(
+        default=False, validation_alias="LOG_RAW_CLI_DIAGNOSTICS"
+    )
+    # When true, log exception text / CLI error strings in messaging (may leak user content).
+    log_messaging_error_details: bool = Field(
+        default=False, validation_alias="LOG_MESSAGING_ERROR_DETAILS"
+    )
+    debug_platform_edits: bool = Field(
+        default=False, validation_alias="DEBUG_PLATFORM_EDITS"
+    )
+    debug_subagent_stack: bool = Field(
+        default=False, validation_alias="DEBUG_SUBAGENT_STACK"
+    )
+
+    # ==================== NIM Settings ====================
+    nim: NimSettings = Field(default_factory=NimSettings)
+
+    # ==================== Voice Note Transcription ====================
+    voice_note_enabled: bool = Field(
+        default=True, validation_alias="VOICE_NOTE_ENABLED"
+    )
+    # Device: "cpu" | "cuda" | "nvidia_nim"
+    # - "cpu"/"cuda": local Whisper (requires voice_local extra: uv sync --extra voice_local)
+    # - "nvidia_nim": NVIDIA NIM Whisper API (requires voice extra: uv sync --extra voice)
+    whisper_device: str = Field(default="cpu", validation_alias="WHISPER_DEVICE")
+    # Whisper model ID or short name (for local Whisper) or NVIDIA NIM model (for nvidia_nim)
+    # Local Whisper: "tiny", "base", "small", "medium", "large-v2", "large-v3", "large-v3-turbo"
+    # NVIDIA NIM: "nvidia/parakeet-ctc-1.1b-asr", "openai/whisper-large-v3", etc.
+    whisper_model: str = Field(default="base", validation_alias="WHISPER_MODEL")
+    # Hugging Face token for faster model downloads (optional, for local Whisper)
+    hf_token: str = Field(default="", validation_alias="HF_TOKEN")
+
+    # ==================== Bot Wrapper Config ====================
+    telegram_bot_token: str | None = None
+    allowed_telegram_user_id: str | None = None
+    discord_bot_token: str | None = Field(
+        default=None, validation_alias="DISCORD_BOT_TOKEN"
+    )
+    allowed_discord_channels: str | None = Field(
+        default=None, validation_alias="ALLOWED_DISCORD_CHANNELS"
+    )
+    allowed_dir: str = ""
+    max_message_log_entries_per_chat: int | None = Field(
+        default=None, validation_alias="MAX_MESSAGE_LOG_ENTRIES_PER_CHAT"
+    )
+
+    # ==================== Server ====================
+    host: str = "0.0.0.0"
+    port: int = 8082
+    # Optional server API key to protect endpoints (Anthropic-style)
+    # Set via env `ANTHROPIC_AUTH_TOKEN`. When empty, no auth is required.
+    anthropic_auth_token: str = Field(
+        default="", validation_alias="ANTHROPIC_AUTH_TOKEN"
+    )
+
+    # Handle empty strings for optional string fields
+    @field_validator(
+        "telegram_bot_token",
+        "allowed_telegram_user_id",
+        "discord_bot_token",
+        "allowed_discord_channels",
+        "model_opus",
+        "model_sonnet",
+        "model_haiku",
+        "enable_opus_thinking",
+        "enable_sonnet_thinking",
+        "enable_haiku_thinking",
+        mode="before",
+    )
+    @classmethod
+    def parse_optional_str(cls, v: Any) -> Any:
+        if v == "":
+            return None
+        return v
+
+    @field_validator("max_message_log_entries_per_chat", mode="before")
+    @classmethod
+    def parse_optional_log_cap(cls, v: Any) -> Any:
+        if v == "" or v is None:
+            return None
+        return v
+
+    @property
+    def claude_workspace(self) -> str:
+        """Return the fixed Claude data workspace path."""
+
+        return str(default_claude_workspace_path())
+
+    @property
+    def claude_cli_bin(self) -> str:
+        """Return the fixed Claude Code binary name."""
+
+        return "claude"
+
+    @property
+    def codex_cli_bin(self) -> str:
+        """Return the fixed Codex CLI binary name."""
+
+        return "codex"
+
+    @field_validator("whisper_device")
+    @classmethod
+    def validate_whisper_device(cls, v: str) -> str:
+        if v not in ("cpu", "cuda", "nvidia_nim"):
+            raise ValueError(
+                f"whisper_device must be 'cpu', 'cuda', or 'nvidia_nim', got {v!r}"
+            )
+        return v
+
+    @field_validator("messaging_platform")
+    @classmethod
+    def validate_messaging_platform(cls, v: str) -> str:
+        if v not in ("telegram", "discord", "none"):
+            raise ValueError(
+                f"messaging_platform must be 'telegram', 'discord', or 'none', got {v!r}"
+            )
+        return v
+
+    @field_validator("messaging_rate_limit")
+    @classmethod
+    def validate_messaging_rate_limit(cls, v: int) -> int:
+        if v <= 0:
+            raise ValueError("messaging_rate_limit must be > 0")
+        return v
+
+    @field_validator("messaging_rate_window")
+    @classmethod
+    def validate_messaging_rate_window(cls, v: float) -> float:
+        if v <= 0:
+            raise ValueError("messaging_rate_window must be > 0")
+        return float(v)
+
+    @field_validator("web_fetch_allowed_schemes")
+    @classmethod
+    def validate_web_fetch_allowed_schemes(cls, v: str) -> str:
+        schemes = [part.strip().lower() for part in v.split(",") if part.strip()]
+        if not schemes:
+            raise ValueError("web_fetch_allowed_schemes must list at least one scheme")
+        for scheme in schemes:
+            if not scheme.isascii() or not scheme.isalpha():
+                raise ValueError(
+                    f"Invalid URL scheme in web_fetch_allowed_schemes: {scheme!r}"
+                )
+        return ",".join(schemes)
+
+    @field_validator("ollama_base_url")
+    @classmethod
+    def validate_ollama_base_url(cls, v: str) -> str:
+        if v.rstrip("/").endswith("/v1"):
+            raise ValueError(
+                "OLLAMA_BASE_URL must be the Ollama root URL for native Anthropic "
+                "messages, e.g. http://localhost:11434 (without /v1)."
+            )
+        return v
+
+    @field_validator("model", "model_opus", "model_sonnet", "model_haiku")
+    @classmethod
+    def validate_model_format(cls, v: str | None) -> str | None:
+        if v is None:
+            return None
+        if "/" not in v:
+            raise ValueError(
+                f"Model must be prefixed with provider type. "
+                f"Valid providers: {', '.join(SUPPORTED_PROVIDER_IDS)}. "
+                f"Format: provider_type/model/name"
+            )
+        provider = v.split("/", 1)[0]
+        if provider not in SUPPORTED_PROVIDER_IDS:
+            supported = ", ".join(f"'{p}'" for p in SUPPORTED_PROVIDER_IDS)
+            raise ValueError(f"Invalid provider: '{provider}'. Supported: {supported}")
+        return v
+
+    @model_validator(mode="after")
+    def check_nvidia_nim_api_key(self) -> Settings:
+        if (
+            self.voice_note_enabled
+            and self.whisper_device == "nvidia_nim"
+            and not self.nvidia_nim_api_key.strip()
+        ):
+            raise ValueError(
+                "NVIDIA_NIM_API_KEY is required when WHISPER_DEVICE is 'nvidia_nim'. "
+                "Set it in your .env file."
+            )
+        return self
+
+    @model_validator(mode="after")
+    def prefer_dotenv_anthropic_auth_token(self) -> Settings:
+        """Let explicit .env auth config override stale shell/client tokens."""
+        dotenv_value = _env_file_override(self.model_config, "ANTHROPIC_AUTH_TOKEN")
+        if dotenv_value is not None:
+            self.anthropic_auth_token = dotenv_value
+        return self
+
+    def uses_process_anthropic_auth_token(self) -> bool:
+        """Return whether proxy auth came from process env, not dotenv config."""
+        if _env_file_override(self.model_config, "ANTHROPIC_AUTH_TOKEN") is not None:
+            return False
+        return bool(os.environ.get("ANTHROPIC_AUTH_TOKEN"))
+
+    @property
+    def provider_type(self) -> str:
+        """Extract provider type from the default model string."""
+        return Settings.parse_provider_type(self.model)
+
+    @property
+    def model_name(self) -> str:
+        """Extract the actual model name from the default model string."""
+        return Settings.parse_model_name(self.model)
+
+    def resolve_model(self, claude_model_name: str) -> str:
+        """Resolve a Claude model name to the configured provider/model string.
+
+        Classifies the incoming Claude model (opus/sonnet/haiku) and
+        returns the model-specific override if configured, otherwise the fallback MODEL.
+        """
+        name_lower = claude_model_name.lower()
+        if "opus" in name_lower and self.model_opus is not None:
+            return self.model_opus
+        if "haiku" in name_lower and self.model_haiku is not None:
+            return self.model_haiku
+        if "sonnet" in name_lower and self.model_sonnet is not None:
+            return self.model_sonnet
+        return self.model
+
+    def configured_chat_model_refs(self) -> tuple[ConfiguredChatModelRef, ...]:
+        """Return unique configured chat provider/model refs with source env keys."""
+        candidates = (
+            ("MODEL", self.model),
+            ("MODEL_OPUS", self.model_opus),
+            ("MODEL_SONNET", self.model_sonnet),
+            ("MODEL_HAIKU", self.model_haiku),
+        )
+        sources_by_ref: dict[str, list[str]] = {}
+        for source, model_ref in candidates:
+            if model_ref is None:
+                continue
+            sources_by_ref.setdefault(model_ref, []).append(source)
+
+        return tuple(
+            ConfiguredChatModelRef(
+                model_ref=model_ref,
+                provider_id=Settings.parse_provider_type(model_ref),
+                model_id=Settings.parse_model_name(model_ref),
+                sources=tuple(sources),
+            )
+            for model_ref, sources in sources_by_ref.items()
+        )
+
+    def resolve_thinking(self, claude_model_name: str) -> bool:
+        """Resolve whether thinking is enabled for an incoming Claude model name."""
+        name_lower = claude_model_name.lower()
+        if "opus" in name_lower and self.enable_opus_thinking is not None:
+            return self.enable_opus_thinking
+        if "haiku" in name_lower and self.enable_haiku_thinking is not None:
+            return self.enable_haiku_thinking
+        if "sonnet" in name_lower and self.enable_sonnet_thinking is not None:
+            return self.enable_sonnet_thinking
+        return self.enable_model_thinking
+
+    def web_fetch_allowed_scheme_set(self) -> frozenset[str]:
+        """Return normalized schemes allowed for web_fetch."""
+        return frozenset(
+            part.strip().lower()
+            for part in self.web_fetch_allowed_schemes.split(",")
+            if part.strip()
+        )
+
+    @staticmethod
+    def parse_provider_type(model_string: str) -> str:
+        """Extract provider type from any 'provider/model' string."""
+        return model_string.split("/", 1)[0]
+
+    @staticmethod
+    def parse_model_name(model_string: str) -> str:
+        """Extract model name from any 'provider/model' string."""
+        return model_string.split("/", 1)[1]
+
+    model_config = SettingsConfigDict(
+        env_file=_env_files(),
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+
+@lru_cache
+def get_settings() -> Settings:
+    """Get cached settings instance."""
+    return Settings()

core/__init__.py

@@ -0,0 +1 @@
+"""Neutral shared application core."""

core/anthropic/__init__.py

@@ -0,0 +1,46 @@
+"""Anthropic protocol helpers shared across API, providers, and integrations."""
+
+from .content import extract_text_from_content, get_block_attr, get_block_type
+from .conversion import (
+    AnthropicToOpenAIConverter,
+    OpenAIConversionError,
+    ReasoningReplayMode,
+    build_base_request_body,
+)
+from .errors import (
+    append_request_id,
+    format_user_error_preview,
+    get_user_facing_error_message,
+)
+from .native_messages_request import sanitize_native_messages_thinking_policy
+from .provider_stream_error import iter_provider_stream_error_sse_events
+from .sse import ContentBlockManager, SSEBuilder, format_sse_event, map_stop_reason
+from .thinking import ContentChunk, ContentType, ThinkTagParser
+from .tokens import get_token_count
+from .tools import HeuristicToolParser
+from .utils import set_if_not_none
+
+__all__ = [
+    "AnthropicToOpenAIConverter",
+    "ContentBlockManager",
+    "ContentChunk",
+    "ContentType",
+    "HeuristicToolParser",
+    "OpenAIConversionError",
+    "ReasoningReplayMode",
+    "SSEBuilder",
+    "ThinkTagParser",
+    "append_request_id",
+    "build_base_request_body",
+    "extract_text_from_content",
+    "format_sse_event",
+    "format_user_error_preview",
+    "get_block_attr",
+    "get_block_type",
+    "get_token_count",
+    "get_user_facing_error_message",
+    "iter_provider_stream_error_sse_events",
+    "map_stop_reason",
+    "sanitize_native_messages_thinking_policy",
+    "set_if_not_none",
+]

core/anthropic/content.py

@@ -0,0 +1,31 @@
+"""Content block helpers for Anthropic-compatible payloads."""
+
+from typing import Any
+
+
+def get_block_attr(block: Any, attr: str, default: Any = None) -> Any:
+    """Get an attribute from a Pydantic model, lightweight object, or dict."""
+    if hasattr(block, attr):
+        return getattr(block, attr)
+    if isinstance(block, dict):
+        return block.get(attr, default)
+    return default
+
+
+def get_block_type(block: Any) -> str | None:
+    """Return a content block type when present."""
+    return get_block_attr(block, "type")
+
+
+def extract_text_from_content(content: Any) -> str:
+    """Extract concatenated text from message content."""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts: list[str] = []
+        for block in content:
+            text = get_block_attr(block, "text", "")
+            if isinstance(text, str) and text:
+                parts.append(text)
+        return "".join(parts)
+    return ""