abstractassistant 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

abstractassistant/core/llm_manager.py

@@ -1,475 +1,382 @@
-"""
-LLM Manager for AbstractAssistant.
+"""Agentic manager for AbstractAssistant (legacy name retained for UI compatibility).
 
-Handles communication with various LLM providers through AbstractCore,
-manages sessions, and provides token counting and status tracking.
+This module used to wrap `abstractcore.BasicSession`. It now hosts an agentic backend
+powered by:
+- AbstractAgent (ReAct/CodeAct/MemAct patterns)
+- AbstractRuntime (durable runs + waits)
+- AbstractCore (providers + tool schemas/normalization)
 """
 
-from typing import Dict, List, Optional, Any
-import time
+from __future__ import annotations
+
 from dataclasses import dataclass
+import threading
+from pathlib import Path
+from typing import Any, Dict, List, Optional
 
-# Import AbstractCore - CLEAN AND SIMPLE
-from abstractcore import create_llm, BasicSession
-from abstractcore.providers import (
-    list_available_providers,
-    get_all_providers_with_models,
-    get_available_models_for_provider,
-    is_provider_available
-)
-
-# Import common tools as requested
-try:
-    from abstractcore.tools.common_tools import (
-        list_files, search_files, read_file, edit_file, 
-        write_file, execute_command, web_search
-    )
-    TOOLS_AVAILABLE = True
-except ImportError as e:
-    TOOLS_AVAILABLE = False
+from .agent_host import AgentHost, AgentHostConfig
+from .session_index import SessionIndex
+from .session_store import SessionStore
 
 
 @dataclass
 class TokenUsage:
-    """Token usage information."""
+    """Best-effort token usage information for UI display."""
+
     current_session: int = 0
     max_context: int = 0
     input_tokens: int = 0
     output_tokens: int = 0
 
 
+class _SessionMessage:
+    """Simple message object with `.role`/`.content` attributes (UI expects this shape)."""
+
+    def __init__(self, role: str, content: str):
+        self.role = str(role or "")
+        self.content = str(content or "")
+
+
+class _SessionView:
+    """Minimal session view exposed to the Qt UI."""
+
+    def __init__(self, messages: List[_SessionMessage]):
+        self.messages = list(messages)
+
+    def get_token_estimate(self) -> int:
+        # Heuristic: ~4 chars per token for English-ish text.
+        total_chars = sum(len(m.content or "") for m in self.messages)
+        return max(0, int(total_chars // 4))
+
+
 class LLMManager:
-    """Manages LLM providers, models, and communication."""
-    
-    def __init__(self, config=None, debug=False):
-        """Initialize the LLM manager.
-        
-        Args:
-            config: Configuration object with LLM settings
-            debug: Enable debug mode
-        """
-        # Import config here to avoid circular imports
+    """Back-compat façade: drive an agentic backend and expose a session-like view."""
+
+    def __init__(self, config=None, debug: bool = False, *, data_dir: Optional[Path] = None):
         if config is None:
             from ..config import Config
+
             config = Config.default()
-        
+
         self.config = config
-        self.debug = debug
-        self.current_provider: str = config.llm.default_provider
-        self.current_model: str = config.llm.default_model
-        self.current_session: Optional[BasicSession] = None
-        self.llm = None
-        
-        # Token tracking
+        self.debug = bool(debug)
+
+        self.data_dir = (Path(data_dir).expanduser() if data_dir is not None else (Path.home() / ".abstractassistant"))
+        self._session_index = SessionIndex(self.data_dir)
+        self._title_seeds: Dict[str, str] = {}
+        self._title_lock = threading.Lock()
+
+        self.current_provider: str = str(getattr(config.llm, "default_provider", "") or "ollama")
+        self.current_model: str = str(getattr(config.llm, "default_model", "") or "qwen3:4b-instruct")
+
+        self._tts_mode: bool = False
+        self._host = self._build_host_for_active_session()
+
+        # UI-facing compatibility fields.
         self.token_usage = TokenUsage()
-        
-        # Use AbstractCore's provider discovery - no hardcoding
-        # Providers are discovered dynamically from AbstractCore
-        
-        # Initialize with default provider
-        self._initialize_llm()
-    
-    def _initialize_llm(self):
-        """Initialize the LLM with current provider and model.
-        
-        CRITICAL: This method ONLY initializes the LLM provider connection.
-        It does NOT create a new session to preserve chat history.
-        Sessions are only created when explicitly requested.
-        """
-        try:
-            if self.debug:
-                if self.debug:
-                    print(f"🔄 Creating LLM with provider={self.current_provider}, model={self.current_model}")
-            
-            old_llm = self.llm  # Keep reference to old LLM
-            self.llm = create_llm(
-                self.current_provider,
-                model=self.current_model,
-                execute_tools=True  # Enable automatic tool execution
+        self.current_session: Optional[_SessionView] = None
+        self.llm = self._best_effort_llm_for_ui()
+        self._refresh_session_view()
+
+    @property
+    def agent_host(self) -> AgentHost:
+        return self._host
+
+    @property
+    def active_session_id(self) -> str:
+        return self._session_index.active_session_id
+
+    def list_sessions(self) -> List[Dict[str, str]]:
+        out: List[Dict[str, str]] = []
+        for rec in self._session_index.records():
+            title = rec.title
+            if str(title).strip().lower() in {"", "new session"}:
+                fallback = self._fallback_title_for_session(rec.session_id)
+                if fallback:
+                    title = fallback
+            out.append(
+                {
+                    "session_id": rec.session_id,
+                    "title": str(title),
+                    "created_at": rec.created_at,
+                    "updated_at": rec.updated_at,
+                }
             )
-            if self.debug:
-                if self.debug:
-                    print(f"✅ LLM created successfully")
-            
-            # CRITICAL FIX: Only create a session if we don't have one yet
-            # This preserves existing sessions when switching providers/models
-            if self.current_session is None:
-                if self.debug:
-                    if self.debug:
-                        print("🆕 No existing session - creating initial session")
-                self.create_new_session()
-            else:
-                # Update existing session with new LLM while preserving history
-                if self.debug:
-                    if self.debug:
-                        print("🔄 Updating existing session with new LLM (preserving history)")
-                self._update_session_llm()
-            
-            # Use AbstractCore's built-in token detection
-            self._update_token_limits_from_abstractcore()
-            
-        except Exception as e:
-            if self.debug:
-                print(f"❌ Error initializing LLM: {e}")
-            import traceback
-            traceback.print_exc()
-            # Keep previous LLM if initialization fails
-    
-    def _update_session_llm(self):
-        """Update existing session with new LLM while preserving message history.
-        
-        This method allows switching providers/models without losing chat history.
-        """
-        if not self.current_session or not self.llm:
+        return out
+
+    def create_new_session(self) -> str:
+        rec = self._session_index.create_session()
+        self._host = self._build_host_for_session(rec.session_id)
+        self.llm = self._best_effort_llm_for_ui()
+        self._refresh_session_view()
+        return rec.session_id
+
+    def switch_session(self, session_id: str) -> None:
+        sid = str(session_id or "").strip()
+        if not sid:
+            raise ValueError("session_id must be non-empty")
+        if sid == self.active_session_id:
             return
-            
+        self._session_index.set_active(sid)
+        self._host = self._build_host_for_session(sid)
+        self.llm = self._best_effort_llm_for_ui()
+        self._refresh_session_view()
+
+    def refresh(self) -> None:
+        """Refresh the UI-facing session view from the durable snapshot."""
         try:
-            # Get current session messages to preserve history
-            existing_messages = getattr(self.current_session, 'messages', [])
-            existing_system_prompt = getattr(self.current_session, 'system_prompt', None)
-            
-            # Prepare tools list (same as in create_new_session)
-            tools = []
-            if TOOLS_AVAILABLE:
-                tools = [
-                    list_files, search_files, read_file, edit_file,
-                    write_file, execute_command, web_search
-                ]
-            
-            # Create new session with new LLM but preserve system prompt
-            system_prompt = existing_system_prompt or (
-                """
-                You are a helpful AI assistant who has access to tools to help the user.
-                Always be a critical and creative thinker who leverage constructive skepticism to progress and evolve its reasoning and answers.
-                Always answer in nicely formatted markdown.
-                """
-            )
-            
-            # Create new session with preserved system prompt
-            new_session = BasicSession(
-                self.llm,
-                system_prompt=system_prompt,
-                tools=tools
-            )
-            
-            # Restore message history by replaying messages
-            # Skip system message (first message) as it's already set
-            for msg in existing_messages[1:] if len(existing_messages) > 1 else []:
-                if hasattr(msg, 'role') and hasattr(msg, 'content'):
-                    # Add message to new session's history without generating response
-                    new_session.messages.append(msg)
-            
-            # Replace current session
-            self.current_session = new_session
-            
-            if self.debug:
-                if self.debug:
-                    print(f"🔄 Session updated with new LLM - preserved {len(existing_messages)} messages")
-                
-        except Exception as e:
-            if self.debug:
-                if self.debug:
-                    print(f"❌ Error updating session LLM (preserving existing session): {e}")
-            # CRITICAL: Do NOT create new session on error - preserve existing session
-            # The user's chat history is more important than a perfect LLM update
-
-    def _update_token_limits_from_abstractcore(self):
-        """Update token limits using AbstractCore's built-in detection."""
-        if self.llm:
-            # AbstractCore automatically detects and configures token limits
-            self.token_usage.max_context = self.llm.max_tokens
-            self.token_usage.input_tokens = 0
-            self.token_usage.output_tokens = 0
-            
-            if self.debug:
-                # Show AbstractCore's token configuration
-                if self.debug:
-                    print(f"📊 {self.llm.get_token_configuration_summary()}")
-    
-    def create_new_session(self, tts_mode: bool = False):
-        """Create a new session with tools - CLEAN AND SIMPLE as per AbstractCore docs.
-        
-        WARNING: This method creates a completely new session, destroying existing chat history.
-        Use update_session_mode() to switch TTS mode while preserving history.
-        
-        Args:
-            tts_mode: If True, use concise prompts optimized for text-to-speech
+            self._session_index.touch(self.active_session_id)
+        except Exception:
+            pass
+        self._refresh_session_view()
+
+    def update_active_session_title_async(self, *, provider: str, model: str, on_done: Optional[Any] = None) -> None:
+        """Best-effort: generate and persist a 1-line title for the active session.
+
+        Uses the active provider/model. Runs in a background thread.
         """
-        if not self.llm:
-            if self.debug:
-                print("❌ No LLM available - cannot create session")
+        try:
+            messages = getattr(self._host.snapshot, "messages", None)
+        except Exception:
+            messages = None
+        if not isinstance(messages, list) or not messages:
             return
-            
-        # Prepare tools list
-        tools = []
-        if TOOLS_AVAILABLE:
-            tools = [
-                list_files, search_files, read_file, edit_file,
-                write_file, execute_command, web_search
-            ]
-            if self.debug:
-                if self.debug:
-                    print(f"🔧 Registering {len(tools)} tools with session")
-        
-        # Choose system prompt based on TTS mode
-        if tts_mode:
-            system_prompt = (
-                """
-                You are a Helpful Voice Assistant. By design, your answers are short and more conversational, unless specifically asked to detail something.
-                You only speak, so never use any text formatting or markdown. Write for a speaker.
-                """
+
+        first_q, last_q = self._extract_first_last_questions(messages)
+        if not first_q or not last_q:
+            return
+
+        seed = f"{first_q}\n---\n{last_q}"
+        sid = self.active_session_id
+        with self._title_lock:
+            if self._title_seeds.get(sid) == seed:
+                return
+            self._title_seeds[sid] = seed
+
+        def _run() -> None:
+            title = self._generate_session_title(provider=provider, model=model, first=first_q, last=last_q)
+            if not title:
+                return
+            try:
+                self._session_index.update_title(sid, title)
+            except Exception:
+                return
+            if callable(on_done):
+                try:
+                    on_done(sid, title)
+                except Exception:
+                    return
+
+        threading.Thread(target=_run, daemon=True).start()
+
+    @staticmethod
+    def _extract_first_last_questions(messages: List[Dict[str, Any]]) -> tuple[Optional[str], Optional[str]]:
+        prompts: List[str] = []
+        for m in messages:
+            if not isinstance(m, dict):
+                continue
+            if str(m.get("role") or "") != "user":
+                continue
+            content = str(m.get("content") or "").strip()
+            if not content:
+                continue
+            # Ignore runtime ask_user responses (not "questions").
+            if content.startswith("[User response]:"):
+                continue
+            prompts.append(content)
+        if not prompts:
+            return None, None
+        return prompts[0], prompts[-1]
+
+    def _fallback_title_for_session(self, session_id: str) -> Optional[str]:
+        """Local-only fallback title derived from transcript (no network)."""
+        sid = str(session_id or "").strip()
+        if not sid:
+            return None
+        try:
+            data_dir = self._session_index.data_dir_for(sid)
+            snap = SessionStore(Path(data_dir) / "session.json").load()
+        except Exception:
+            return None
+        if snap is None or not isinstance(getattr(snap, "messages", None), list):
+            return None
+        first, last = self._extract_first_last_questions(list(snap.messages))
+        if not first and not last:
+            return None
+
+        def _clean(s: Optional[str]) -> str:
+            txt = str(s or "").replace("\n", " ").replace("\r", " ").strip()
+            return " ".join(txt.split())
+
+        def _trunc(txt: str, n: int) -> str:
+            t = _clean(txt)
+            if len(t) <= n:
+                return t
+            return (t[: max(0, n - 1)].rstrip() + "…").strip()
+
+        first_txt = _clean(first)
+        last_txt = _clean(last)
+        if not first_txt:
+            return _trunc(last_txt, 80) if last_txt else None
+        if not last_txt or first_txt == last_txt:
+            return _trunc(first_txt, 80)
+        return f"{_trunc(first_txt, 34)} → {_trunc(last_txt, 34)}"
+
+    @staticmethod
+    def _generate_session_title(*, provider: str, model: str, first: str, last: str) -> Optional[str]:
+        """Return a single-line title or None (best-effort)."""
+        try:
+            from abstractcore import create_llm
+        except Exception:
+            return None
+
+        try:
+            llm = create_llm(str(provider), model=str(model))
+            prompt = (
+                "Generate a single-line title for this chat session.\n"
+                "- Max 60 characters.\n"
+                "- No quotes.\n"
+                "- Be specific.\n\n"
+                f"First question: {first}\n"
+                f"Most recent question: {last}\n"
             )
-        else:
-            system_prompt = (
-                """
-                You are a helpful AI assistant who has access to tools to help the user.
-                Always be a critical and creative thinker who leverage constructive skepticism to progress and evolve its reasoning and answers.
-                Always answer in nicely formatted markdown.
-                """
+            resp = llm.generate(prompt, max_output_tokens=64, temperature=0.2)
+            text = getattr(resp, "content", None)
+            if text is None:
+                text = str(resp)
+            title = str(text or "").strip().splitlines()[0].strip()
+            title = title.strip(" \"'“”")
+            if len(title) > 80:
+                title = title[:80].rstrip()
+            return title or None
+        except Exception:
+            return None
+
+    def _build_host_for_active_session(self) -> AgentHost:
+        return self._build_host_for_session(self.active_session_id)
+
+    def _build_host_for_session(self, session_id: str) -> AgentHost:
+        data_dir = self._session_index.data_dir_for(session_id)
+        return AgentHost(
+            AgentHostConfig(
+                provider=self.current_provider,
+                model=self.current_model,
+                agent_kind="react",
+                data_dir=data_dir,
             )
-        
-        # Create session with tools (tool execution enabled at provider level)
-        self.current_session = BasicSession(
-            self.llm, 
-            system_prompt=system_prompt,
-            tools=tools
         )
-        
-        # Reset token count for new session
-        self.token_usage.current_session = 0
-        
-        if self.debug:
-            if TOOLS_AVAILABLE:
-                if self.debug:
-                    print(f"✅ Created new AbstractCore session with tools ({'TTS mode' if tts_mode else 'normal mode'})")
-            else:
-                if self.debug:
-                    print(f"✅ Created new AbstractCore session (no tools available, {'TTS mode' if tts_mode else 'normal mode'})")
 
-    def update_session_mode(self, tts_mode: bool = False):
-        """Update session mode (TTS vs normal) while preserving chat history.
-        
-        This method changes the system prompt behavior without destroying the session.
-        
-        Args:
-            tts_mode: If True, switch to TTS-optimized mode; if False, switch to normal mode
-        """
-        if not self.current_session:
-            # No existing session - only create if this is initial startup
-            if self.debug:
-                if self.debug:
-                    print("⚠️  No session exists - creating initial session for mode update")
-            self.create_new_session(tts_mode=tts_mode)
-            return
-            
+    def _best_effort_llm_for_ui(self) -> Optional[Any]:
+        """Return the underlying AbstractCore provider instance when available (best-effort)."""
         try:
-            # Get current session messages to preserve history
-            existing_messages = getattr(self.current_session, 'messages', [])
-            
-            # Prepare tools list
-            tools = []
-            if TOOLS_AVAILABLE:
-                tools = [
-                    list_files, search_files, read_file, edit_file,
-                    write_file, execute_command, web_search
-                ]
-            
-            # Choose system prompt based on TTS mode
-            if tts_mode:
-                system_prompt = (
-                    """
-                    You are a Helpful Voice Assistant. By design, your answers are short and more conversational, unless specifically asked to detail something.
-                    You only speak, so never use any text formatting or markdown. Write for a speaker.
-                    """
-                )
-            else:
-                system_prompt = (
-                    """
-                    You are a helpful AI assistant who has access to tools to help the user.
-                    Always be a critical and creative thinker who leverage constructive skepticism to progress and evolve its reasoning and answers.
-                    Always answer in nicely formatted markdown.
-                    """
-                )
-            
-            # Create new session with updated system prompt
-            new_session = BasicSession(
-                self.llm,
-                system_prompt=system_prompt,
-                tools=tools
-            )
-            
-            # Restore message history by replaying messages
-            # Skip system message (first message) as it's already set with new prompt
-            for msg in existing_messages[1:] if len(existing_messages) > 1 else []:
-                if hasattr(msg, 'role') and hasattr(msg, 'content'):
-                    # Add message to new session's history without generating response
-                    new_session.messages.append(msg)
-            
-            # Replace current session
-            self.current_session = new_session
-            
-            if self.debug:
-                if self.debug:
-                    print(f"🔄 Session mode updated to {'TTS' if tts_mode else 'normal'} - preserved {len(existing_messages)} messages")
-                
-        except Exception as e:
-            if self.debug:
-                if self.debug:
-                    print(f"❌ Error updating session mode (preserving existing session): {e}")
-            # CRITICAL: Do NOT create new session on error - preserve existing session
-            # The user's chat history is more important than a perfect mode switch
-    
+            rt = getattr(self._host, "_runtime", None)
+            client = getattr(rt, "_abstractcore_llm_client", None)
+            getter = getattr(client, "get_provider_instance", None)
+            if callable(getter):
+                return getter(provider=self.current_provider, model=self.current_model)
+        except Exception:
+            return None
+        return None
+
+    def _refresh_session_view(self) -> None:
+        snap = self._host.snapshot
+        msgs: List[_SessionMessage] = []
+        for m in snap.messages:
+            if not isinstance(m, dict):
+                continue
+            role = str(m.get("role") or "")
+            content = str(m.get("content") or "")
+            if role == "system":
+                continue
+            msgs.append(_SessionMessage(role=role, content=content))
+        self.current_session = _SessionView(msgs)
+        if self.current_session:
+            self.token_usage.current_session = self.current_session.get_token_estimate()
+
+        # Best-effort max context from AbstractCore detection (when `llm` is present).
+        max_tokens = None
+        try:
+            max_tokens = getattr(self.llm, "max_tokens", None)
+        except Exception:
+            max_tokens = None
+        if isinstance(max_tokens, int) and max_tokens > 0:
+            self.token_usage.max_context = max_tokens
+
+    def reset_active_session(self, tts_mode: bool = False) -> None:
+        self._tts_mode = bool(tts_mode)
+        self._host.clear_messages()
+        self._refresh_session_view()
+
     def clear_session(self):
-        """Clear current session and create a new one."""
-        self.create_new_session()
-    
-    def save_session(self, filepath: str):
-        """Save current session to file using AbstractCore's built-in save."""
+        self.reset_active_session(tts_mode=False)
+
+    def update_session_mode(self, tts_mode: bool = False):
+        self._tts_mode = bool(tts_mode)
+
+    def save_session(self, filepath: str) -> bool:
         try:
-            if not self.current_session:
-                if self.debug:
-                    if self.debug:
-                        print("⚠️  No session to save")
-                return False
-            
-            # Use AbstractCore's built-in save method
-            self.current_session.save(filepath)
-            
-            if self.debug:
-                if self.debug:
-                    print(f"✅ Session saved to {filepath}")
+            self._host.export_messages(Path(filepath))
             return True
-            
-        except Exception as e:
-            if self.debug:
-                if self.debug:
-                    print(f"❌ Error saving session: {e}")
+        except Exception:
             return False
-    
-    def load_session(self, filepath: str):
-        """Load session from file using AbstractCore's built-in load."""
+
+    def load_session(self, filepath: str) -> bool:
         try:
-            # Prepare tools list (same as in create_new_session)
-            tools = []
-            if TOOLS_AVAILABLE:
-                tools = [
-                    list_files, search_files, read_file, edit_file,
-                    write_file, execute_command, web_search
-                ]
-            
-            # Use AbstractCore's built-in load method (class method)
-            self.current_session = BasicSession.load(filepath, provider=self.llm, tools=tools)
-            
-            # Update token limits
-            self._update_token_limits_from_abstractcore()
-            
-            if self.debug:
-                if self.debug:
-                    print(f"✅ Session loaded from {filepath}")
+            self._host.import_messages(Path(filepath))
+            self._refresh_session_view()
             return True
-            
-        except Exception as e:
-            if self.debug:
-                if self.debug:
-                    print(f"❌ Error loading session: {e}")
+        except Exception:
             return False
-    
-    def get_providers(self) -> List[Dict[str, Any]]:
-        """Get available providers using AbstractCore's discovery system."""
-        return get_all_providers_with_models()
-    
-    def get_models(self, provider: str) -> List[str]:
-        """Get available models for a provider using AbstractCore."""
-        try:
-            return get_available_models_for_provider(provider)
-        except Exception as e:
-            if self.debug:
-                if self.debug:
-                    print(f"⚠️  Could not get models for {provider}: {e}")
-            return []
-    
+
     def set_provider(self, provider: str, model: Optional[str] = None):
-        """Set the active provider and optionally model."""
-        # AbstractCore validates provider availability
-        if is_provider_available(provider):
-            self.current_provider = provider
-            
-            # Set model if provided, otherwise keep current or use first available
-            if model:
-                self.current_model = model
-            
-            # Reinitialize LLM
-            self._initialize_llm()
-        elif self.debug:
-            if self.debug:
-                print(f"⚠️  Provider {provider} not available")
-    
+        self.current_provider = str(provider or "").strip() or self.current_provider
+        if model is not None:
+            self.current_model = str(model or "").strip() or self.current_model
+        self.llm = self._best_effort_llm_for_ui()
+
     def set_model(self, model: str):
-        """Set the active model for current provider."""
-        self.current_model = model
-        self._initialize_llm()
-    
-    def generate_response(self, message: str, provider: str = None, model: str = None, media: Optional[List[str]] = None) -> str:
-        """Generate a response using the session for context persistence.
-
-        Args:
-            message: User message
-            provider: Optional provider override
-            model: Optional model override
-            media: Optional list of file paths to attach (images, PDFs, Office docs, etc.)
-
-        Returns:
-            Generated response text
+        self.current_model = str(model or "").strip() or self.current_model
+        self.llm = self._best_effort_llm_for_ui()
+
+    def generate_response(
+        self,
+        message: str,
+        provider: Optional[str] = None,
+        model: Optional[str] = None,
+        media: Optional[List[str]] = None,
+    ) -> str:
+        """Run one agentic turn and return the final answer text.
+
+        Note: tool approval is currently auto-managed:
+        - safe/known read-only tools are auto-approved
+        - dangerous/unknown tools are denied unless explicitly enabled in the UI layer
         """
-        # Use provided provider/model or current ones
-        if provider and provider != self.current_provider:
-            self.set_provider(provider, model)
-        elif model and model != self.current_model:
-            self.set_model(model)
+        provider_eff = str(provider or "").strip() or self.current_provider
+        model_eff = str(model or "").strip() or self.current_model
+
+        system_extra = None
+        if self._tts_mode:
+            system_extra = (
+                "You are in voice mode.\n"
+                "- Keep responses concise and conversational.\n"
+                "- Avoid markdown and heavy formatting.\n"
+            )
+
+        final = ""
+        for ev in self._host.run_turn(
+            user_text=str(message),
+            attachments=list(media) if media else None,
+            provider=provider_eff,
+            model=model_eff,
+            system_prompt_extra=system_extra,
+        ):
+            if isinstance(ev, dict) and ev.get("type") == "assistant":
+                final = str(ev.get("content") or "")
+
+        # Refresh session view for history/token display.
+        self._refresh_session_view()
+        return final
 
-        try:
-            # Ensure we have a session - but only create if absolutely necessary
-            if self.current_session is None:
-                if self.debug:
-                    if self.debug:
-                        print("⚠️  No session exists - creating initial session for first use")
-                self.create_new_session()
-
-            # Generate response using session with optional media files
-            # AbstractCore 2.4.5+ supports media=[] parameter for file attachments
-            if media and len(media) > 0:
-                response = self.current_session.generate(message, media=media)
-            else:
-                response = self.current_session.generate(message)
-
-            # Handle response format
-            if hasattr(response, 'content'):
-                response_text = response.content
-            else:
-                response_text = str(response)
-
-            return response_text
-
-        except Exception as e:
-            return f"Error generating response: {str(e)}"
-    
     def get_token_usage(self) -> TokenUsage:
-        """Get current token usage using AbstractCore's built-in estimation."""
-        if self.current_session:
-            # Use AbstractCore's token estimation
-            estimated = self.current_session.get_token_estimate()
-            self.token_usage.current_session = estimated
+        self._refresh_session_view()
         return self.token_usage
-    
-    def get_status_info(self) -> Dict[str, Any]:
-        """Get current status information for UI display."""
-        # Get fresh token estimate from AbstractCore
-        token_estimate = self.current_session.get_token_estimate() if self.current_session else 0
-        
-        return {
-            "provider": self.current_provider,
-            "model": self.current_model,
-            "tokens_current": token_estimate,
-            "tokens_max": self.token_usage.max_context,
-            "status": "ready"  # Will be updated by app state
-        }