@aj-archipelago/cortex 1.3.65 → 1.3.67

package/helper-apps/cortex-autogen2/task_processor.py

@@ -28,6 +28,10 @@ class TaskProcessor:
         self.gpt41_model_client = None
         self.progress_tracker = None
         self.final_progress_sent = False
+        # Background progress worker components
+        self._progress_queue: Optional[asyncio.Queue] = None
+        self._progress_worker_task: Optional[asyncio.Task] = None
+        self._last_summary_by_request: Dict[str, str] = {}
         
     async def initialize(self):
         """Initialize model clients and services."""
@@ -39,9 +43,11 @@ class TaskProcessor:
         CORTEX_API_BASE_URL = os.getenv("CORTEX_API_BASE_URL", "http://host.docker.internal:4000/v1")
 
         # Define ModelInfo for custom models
-        o3_model_info = ModelInfo(model="o3", name="Cortex o3", max_tokens=8192, cost_per_token=0.0, vision=False, function_calling=True, json_output=False, family="openai", structured_output=False) # Placeholder cost
-        o4_mini_model_info = ModelInfo(model="o4-mini", name="Cortex o4-mini", max_tokens=128000, cost_per_token=0.0, vision=False, function_calling=True, json_output=False, family="openai", structured_output=False) # Placeholder cost
-        gpt41_model_info = ModelInfo(model="gpt-4.1", name="Cortex gpt-4.1", max_tokens=8192, cost_per_token=0.0, vision=False, function_calling=True, json_output=False, family="openai", structured_output=False) # Placeholder cost
+        o3_model_info = ModelInfo(model="o3", name="Cortex o3", max_tokens=128000, cost_per_token=0.0, vision=False, function_calling=True, json_output=False, family="openai", structured_output=False)
+        o4_mini_model_info = ModelInfo(model="o4-mini", name="Cortex o4-mini", max_tokens=128000, cost_per_token=0.0, vision=False, function_calling=True, json_output=False, family="openai", structured_output=False) 
+        gpt41_model_info = ModelInfo(model="gpt-4.1", name="Cortex gpt-4.1", max_tokens=8192, cost_per_token=0.0, vision=False, function_calling=True, json_output=False, family="openai", structured_output=False) 
+        gpt5_model_info = ModelInfo(model="gpt-5", name="Cortex gpt-5", max_tokens=128000, cost_per_token=0.0, vision=False, function_calling=True, json_output=False, family="openai", structured_output=False) 
+        claude_4_sonnet_model_info = ModelInfo(model="claude-4-sonnet", name="Cortex claude-4-sonnet", max_tokens=128000, cost_per_token=0.0, vision=False, function_calling=True, json_output=False, family="openai", structured_output=False) 
 
         self.o3_model_client = OpenAIChatCompletionClient(
             model="o3",
@@ -66,12 +72,78 @@ class TaskProcessor:
             timeout=600,
             model_info=gpt41_model_info # Pass model_info
         )
+
+        self.gpt5_model_client = OpenAIChatCompletionClient(
+            model="gpt-5",
+            api_key=CORTEX_API_KEY,
+            base_url=CORTEX_API_BASE_URL,
+            timeout=600,
+            model_info=gpt5_model_info # Pass model_info
+        )
+
+        self.claude_4_sonnet_model_client = OpenAIChatCompletionClient(
+            model="claude-4-sonnet",
+            api_key=CORTEX_API_KEY,
+            base_url=CORTEX_API_BASE_URL,
+            timeout=600,
+            model_info=claude_4_sonnet_model_info # Pass model_info
+        )
         
         self.progress_tracker = await get_redis_publisher()
+        # Ensure background progress worker is running
+        await self._ensure_progress_worker()
+
+    async def _ensure_progress_worker(self) -> None:
+        """Start a single background worker to process progress updates asynchronously."""
+        try:
+            if self._progress_queue is None:
+                # Bounded queue to avoid memory growth; newest updates replace when full
+                self._progress_queue = asyncio.Queue(maxsize=256)
+            if self._progress_worker_task is None or self._progress_worker_task.done():
+                self._progress_worker_task = asyncio.create_task(self._progress_worker_loop())
+        except Exception as e:
+            logger.warning(f"Failed to start progress worker: {e}")
+
+    async def _progress_worker_loop(self) -> None:
+        """Continuously consume progress events, summarize, de-duplicate, and publish transient updates."""
+        try:
+            while True:
+                try:
+                    event = await self._progress_queue.get()
+                    if not event:
+                        self._progress_queue.task_done()
+                        continue
+                    req_id = event.get("task_id")
+                    pct = float(event.get("percentage") or 0.0)
+                    content = event.get("content")
+                    msg_type = event.get("message_type")
+                    source = event.get("source")
+                    # Summarize in background
+                    summary = await self.summarize_progress(content, msg_type, source)
+                    if summary:
+                        last = self._last_summary_by_request.get(req_id)
+                        if last != summary:
+                            self._last_summary_by_request[req_id] = summary
+                            try:
+                                await self.progress_tracker.set_transient_update(req_id, pct, summary)
+                            except Exception as pub_err:
+                                logger.debug(f"Progress transient publish error for {req_id}: {pub_err}")
+                    self._progress_queue.task_done()
+                except asyncio.CancelledError:
+                    raise
+                except Exception as loop_err:
+                    logger.debug(f"Progress worker loop error: {loop_err}")
+        except asyncio.CancelledError:
+            logger.info("Progress worker task cancelled")
+        except Exception as e:
+            logger.warning(f"Progress worker terminated unexpectedly: {e}")
 
     async def summarize_progress(self, content: str, message_type: str = None, source: str = None) -> str:
         """Summarize progress content for display with intelligent filtering."""
         try:
+            # Skip internal selector or housekeeping messages entirely
+            if self._is_internal_selector_message(content):
+                return None
             # Filter out technical/internal messages that shouldn't be shown to users
             if self._should_skip_progress_update(content, message_type, source):
                 return None
@@ -81,37 +153,51 @@ class TaskProcessor:
             if not cleaned_content:
                 return None
             
-            prompt = f"""Generate a concise, engaging, and user-friendly progress update (5-15 words) that clearly indicates what the AI is currently working on. Include an appropriate emoji.
+            prompt = f"""Transform this agent activity into a delightful, crystal-clear progress update (8-15 words) that makes non-technical users feel excited about what's happening. Start with a perfect emoji.
 
-Context: This is for a user-facing progress indicator in a React app.
+Context: This appears in a live progress indicator for end users who aren't coders.
 
 Current Activity: {cleaned_content}
-Agent Source: {source if source else "Unknown"}
-
-Requirements:
-- Be positive and professional
-- Focus on what the user will benefit from
-- Avoid technical jargon
-- Use engaging, action-oriented language
-- Include a relevant emoji
-- Consider the agent source to provide context (e.g., coder_agent = coding, presenter_agent = creating presentation)
-
-Examples of good updates:
-- "🔍 Researching the latest trends"
-- "📊 Analyzing data patterns" 
-- "🎨 Creating visual content"
-- "📝 Compiling your report"
-- "🚀 Finalizing results"
-- "💻 Writing code for your request"
-- "☁️ Uploading files to cloud storage"
-
-Bad examples (avoid):
-- "Task terminated"
-- "Processing internal data"
-- "Executing tool calls"
-- "TERMINATE"
-
-Generate only the progress update:"""
+Agent Role: {source if source else "Unknown"}
+
+🎨 Emoji Guide (pick the most fitting):
+Planning/Thinking: 🧭 🗺️ 💡 🎯 🤔
+Research/Search: 🔎 🔍 🌐 📚 🕵️
+Data/Analysis: 📊 📈 📉 🧮 💹
+Writing/Creating: ✍️ 📝 🖊️ ✨ 🎨
+Images/Media: 🖼️ 📸 🎬 🌈 🖌️
+Code/Technical: 💻 ⚙️ 🛠️ 🔧 ⚡
+Files/Upload: 📁 ☁️ 📤 💾 🗂️
+Success/Done: ✅ 🎉 🏆 🎊 ⭐
+
+✨ Writing Style:
+- ENGAGING: Use vivid, active verbs that paint a picture (discovering, crafting, weaving, building, hunting)
+- HUMAN: Conversational and warm, like a helpful colleague updating you
+- CLEAR: Zero jargon, no technical terms, no agent/tool names
+- SPECIFIC: Say what's actually being created/found (not just "processing data")
+- UPBEAT: Positive energy, but not over-the-top
+- SHORT: 8-15 words max - every word must earn its place
+
+🌟 Great Examples (follow these patterns):
+- "🔍 Hunting down the perfect images for your presentation"
+- "📊 Crunching numbers to reveal hidden trends"
+- "✨ Weaving everything together into a polished report"
+- "🎨 Designing eye-catching charts that tell the story"
+- "📚 Diving deep into research to find golden insights"
+- "🖼️ Gathering stunning visuals to bring ideas to life"
+- "💡 Mapping out the smartest approach to tackle this"
+- "☁️ Packaging everything up for easy download"
+- "🔎 Exploring databases to uncover the answers"
+- "✍️ Crafting a compelling narrative from the data"
+
+❌ Avoid These (too boring/technical):
+- "Processing data" (vague)
+- "Executing SQL query" (jargon)
+- "Running code" (technical)
+- "Your report is ready" (premature/addressing user)
+- "Task terminated" (robotic)
+
+Return ONLY the update line with emoji - nothing else:"""
             
             messages = [UserMessage(content=str(prompt), source="summarize_progress_function")]
             
@@ -128,6 +214,10 @@ Generate only the progress update:"""
             
         content_str = str(content).strip().upper()
         
+        # Skip internal selector prompts or bare role names
+        if self._is_internal_selector_message(content):
+            return True
+
         # Skip termination messages
         if content_str == "TERMINATE" or "TERMINATE" in content_str:
             return True
@@ -183,13 +273,66 @@ Generate only the progress update:"""
             
         return cleaned
 
+    def _is_internal_selector_message(self, content: str) -> bool:
+        """Detect AutoGen selector prompts and bare role selections to avoid surfacing them."""
+        if not content:
+            return False
+        text = str(content).strip()
+        selector_markers = [
+            "You are in a role play game.",
+            "select the next role",
+            "Only return the role.",
+        ]
+        for marker in selector_markers:
+            if marker.lower() in text.lower():
+                return True
+
+        role_names = {
+            "planner_agent", "coder_agent", "code_executor", "terminator_agent",
+            "presenter_agent", "file_cloud_uploader_agent", "aj_sql_agent",
+            "aj_article_writer_agent", "cognitive_search_agent", "web_search_agent"
+        }
+        # If the entire content is just a role name, treat as internal
+        if text in role_names:
+            return True
+
+        # Treat provider schema errors about tool_calls/MultiMessage as internal noise
+        try:
+            lowered = text.lower()
+            if ("tool_calls" in lowered) and ("multimessage" in lowered) and ("field" in lowered or "variable" in lowered):
+                return True
+        except Exception:
+            pass
+        return False
+
     async def handle_progress_update(self, task_id: str, percentage: float, content: str, message_type: str = None, source: str = None):
-        """Handle progress updates with intelligent summarization."""
-        summarized_content = await self.summarize_progress(content, message_type, source)
-        
-        # Only publish if we have meaningful content
-        if summarized_content:
-            await self.progress_tracker.publish_progress(task_id, percentage, summarized_content)
+        """Enqueue progress updates for the background worker to process (non-blocking)."""
+        try:
+            if self._progress_queue is None:
+                await self._ensure_progress_worker()
+            event = {
+                "task_id": task_id,
+                "percentage": percentage,
+                "content": content,
+                "message_type": message_type,
+                "source": source,
+            }
+            # Prefer non-blocking put; if full, drop the oldest and retry once
+            try:
+                self._progress_queue.put_nowait(event)
+            except asyncio.QueueFull:
+                try:
+                    # Drop one item to make room
+                    _ = self._progress_queue.get_nowait()
+                    self._progress_queue.task_done()
+                except Exception:
+                    pass
+                try:
+                    self._progress_queue.put_nowait(event)
+                except Exception:
+                    pass
+        except Exception as e:
+            logger.debug(f"handle_progress_update enqueue error: {e}")
 
     async def publish_final(self, task_id: str, message: str, data: Any = None) -> None:
         """Publish a final 1.0 progress message once."""
@@ -209,26 +352,49 @@ Generate only the progress update:"""
             task_completed_percentage = 0.05
             task = task_content
 
-            # Send initial progress update
-            await self.progress_tracker.publish_progress(task_id, 0.05, "🚀 Starting your task...")
+            # Per-request working directory: isolate artifacts under /tmp/coding/<task_id>
+            try:
+                base_wd = os.getenv("CORTEX_WORK_DIR", "/tmp/coding")
+                # In Azure Functions, force /tmp for write access
+                if os.getenv("WEBSITE_INSTANCE_ID") and base_wd.startswith("/app/"):
+                    base_wd = "/tmp/coding"
+                import time
+                req_dir_name = f"req_{task_id}" if task_id else f"req_{int(time.time())}"
+                request_work_dir = os.path.join(base_wd, req_dir_name)
+                os.makedirs(request_work_dir, exist_ok=True)
+                os.environ["CORTEX_WORK_DIR"] = request_work_dir
+                # pass to get_agents so all tools use this dir
+                request_work_dir_for_agents = request_work_dir
+            except Exception:
+                # Fallback to base directory if per-request directory cannot be created
+                try:
+                    os.makedirs(os.getenv("CORTEX_WORK_DIR", "/tmp/coding"), exist_ok=True)
+                except Exception:
+                    pass
+
+            # Send initial progress update (transient only)
+            await self.progress_tracker.set_transient_update(task_id, 0.05, "🚀 Starting your task...")
 
             termination = HandoffTermination(target="user") | TextMentionTermination("TERMINATE")
 
-            agents, presenter_agent = await get_agents(
+            agents, presenter_agent, terminator_agent = await get_agents(
                 self.gpt41_model_client,
                 self.o3_model_client,
-                self.gpt41_model_client
+                self.gpt41_model_client,
+                request_work_dir=request_work_dir_for_agents if 'request_work_dir_for_agents' in locals() else None
             )
 
             team = SelectorGroupChat(
                 participants=agents,
                 model_client=self.gpt41_model_client,
                 termination_condition=termination,
-                max_turns=10000
+                max_turns=200
             )
 
             messages = []
             uploaded_file_urls = {}
+            uploaded_files_list: List[Dict[str, Any]] = []
+            external_media_urls: List[str] = []
             final_result_content = []
 
             detailed_task = f"""
@@ -238,6 +404,9 @@ Generate only the progress update:"""
             """
 
             stream = team.run_stream(task=task)
+            # Loop guard for repeating provider schema errors (e.g., tool_calls/MultiMessage)
+            repeated_schema_error_count = 0
+            last_schema_error_seen = False
             async for message in stream:
                 messages.append(message)
                 source = message.source if hasattr(message, 'source') else None
@@ -249,7 +418,27 @@ Generate only the progress update:"""
                 if task_completed_percentage >= 1.0:
                     task_completed_percentage = 0.99
                     
-                if content:
+                # Loop-guard detection: break early if the same schema error repeats
+                try:
+                    ctext = str(content) if content is not None else ""
+                    is_schema_err = ("tool_calls" in ctext) and ("MultiMessage" in ctext)
+                    if is_schema_err:
+                        if last_schema_error_seen:
+                            repeated_schema_error_count += 1
+                        else:
+                            repeated_schema_error_count = 1
+                        last_schema_error_seen = True
+                        # If schema error repeats too many times, stop the loop to avoid getting stuck
+                        if repeated_schema_error_count >= 3:
+                            logger.warning("Breaking team.run_stream due to repeated MultiMessage/tool_calls schema errors.")
+                            break
+                    else:
+                        last_schema_error_seen = False
+                        repeated_schema_error_count = 0
+                except Exception:
+                    pass
+
+                if content and not self._is_internal_selector_message(content):
                     processed_content_for_progress = content
                     if message.type == "ToolCallExecutionEvent" and hasattr(message, 'content') and isinstance(message.content, list):
                         error_contents = [res.content for res in message.content if hasattr(res, 'is_error') and res.is_error]
@@ -264,105 +453,187 @@ Generate only the progress update:"""
                             if isinstance(json_content, dict):
                                 if "download_url" in json_content and "blob_name" in json_content:
                                     uploaded_file_urls[json_content["blob_name"]] = json_content["download_url"]
-                                    final_result_content.append(f"Uploaded file: [{json_content['blob_name']}]({json_content['download_url']})")
+                                # collect external media from known keys
+                                for k in ("images", "image_urls", "media", "videos", "thumbnails", "assets"):
+                                    try:
+                                        vals = json_content.get(k)
+                                        if isinstance(vals, list):
+                                            for v in vals:
+                                                if isinstance(v, str) and v.startswith("http"):
+                                                    external_media_urls.append(v)
+                                        elif isinstance(vals, dict):
+                                            for v in vals.values():
+                                                if isinstance(v, str) and v.startswith("http"):
+                                                    external_media_urls.append(v)
+                                    except Exception:
+                                        pass
                             elif isinstance(json_content, list):
                                 for item in json_content:
                                     if isinstance(item, dict) and "download_url" in item and "blob_name" in item:
                                         uploaded_file_urls[item["blob_name"]] = item["download_url"]
-                                        final_result_content.append(f"Uploaded file: [{item['blob_name']}]({item['download_url']})")
+                                    # look for url-like fields
+                                    if isinstance(item, dict):
+                                        for key in ("url", "image", "thumbnail", "video", "download_url"):
+                                            try:
+                                                val = item.get(key)
+                                                if isinstance(val, str) and val.startswith("http"):
+                                                    external_media_urls.append(val)
+                                            except Exception:
+                                                pass
                             # otherwise, ignore scalars like numbers/strings
                         except json.JSONDecodeError:
-                            pass
+                            # best-effort regex scrape of http(s) URLs that look like media
+                            try:
+                                import re
+                                for m in re.findall(r"https?://[^\s)\]}]+", content):
+                                    if any(m.lower().endswith(ext) for ext in (".png", ".jpg", ".jpeg", ".webp", ".gif", ".mp4", ".webm", ".mov")):
+                                        external_media_urls.append(m)
+                            except Exception:
+                                pass
                     
                     final_result_content.append(str(content))
+                    # Enqueue progress update for background processing (non-blocking)
                     asyncio.create_task(self.handle_progress_update(task_id, task_completed_percentage, processed_content_for_progress, message.type, source))
 
-            await self.progress_tracker.publish_progress(task_id, 0.95, "✨ Finalizing your results...")
-
-            # Targeted auto-upload: if no URLs yet, opportunistically upload recent deliverables created in this run.
-            # Fast, non-recursive, and limited to known dirs and extensions.
             try:
-                if not uploaded_file_urls:
-                    import time
-                    now = time.time()
-                    max_age_seconds = 15 * 60  # last 15 minutes
-                    deliverable_exts = {".pptx", ".ppt", ".csv", ".png", ".jpg", ".jpeg", ".pdf"}
-                    candidate_dirs: List[str] = []
-                    try:
-                        wd = os.getenv("CORTEX_WORK_DIR", "/tmp/coding")
-                        # In Azure Functions, prefer /tmp for write access
-                        if os.getenv("WEBSITE_INSTANCE_ID") and wd.startswith("/app/"):
-                            wd = "/tmp/coding"
-                        candidate_dirs.append(wd)
-                    except Exception:
-                        pass
-                    candidate_dirs.append("/tmp/coding")
+                # Finalizing update (transient only)
+                await self.progress_tracker.set_transient_update(task_id, 0.95, "✨ Finalizing your results...")
+            except Exception:
+                pass
 
-                    recent_files: List[str] = []
-                    for d in candidate_dirs:
-                        if not d:
-                            continue
-                        # Ensure directory exists if possible
-                        try:
-                            os.makedirs(d, exist_ok=True)
-                        except Exception:
-                            pass
-                        if not os.path.isdir(d):
-                            continue
-                        try:
-                            for name in os.listdir(d):
-                                fp = os.path.join(d, name)
-                                if not os.path.isfile(fp):
-                                    continue
+            # No fallback file generation: if required assets are missing, allow termination to report inability
+            except Exception:
+                # Catch-all for the outer deliverables-referencing try block
+                pass
+
+            # Per-request auto-upload: select best deliverables (avoid multiple near-identical PPTX)
+            try:
+                deliverable_exts = {".pptx", ".ppt", ".csv", ".png", ".jpg", ".jpeg", ".pdf", ".zip"}
+                req_dir = os.getenv("CORTEX_WORK_DIR", "/tmp/coding")
+                selected_paths: List[str] = []
+                if os.path.isdir(req_dir):
+                    # Gather candidates by extension
+                    candidates_by_ext: Dict[str, List[Dict[str, Any]]] = {}
+                    for root, _, files in os.walk(req_dir):
+                        for name in files:
+                            try:
                                 _, ext = os.path.splitext(name)
-                                if ext.lower() not in deliverable_exts:
+                                ext = ext.lower()
+                                if ext not in deliverable_exts:
                                     continue
+                                fp = os.path.join(root, name)
+                                size = 0
+                                mtime = 0.0
                                 try:
-                                    mtime = os.path.getmtime(fp)
-                                    if now - mtime <= max_age_seconds:
-                                        recent_files.append(fp)
+                                    st = os.stat(fp)
+                                    size = int(getattr(st, 'st_size', 0))
+                                    mtime = float(getattr(st, 'st_mtime', 0.0))
                                 except Exception:
-                                    continue
-                        except Exception:
-                            continue
+                                    pass
+                                lst = candidates_by_ext.setdefault(ext, [])
+                                lst.append({"path": fp, "size": size, "mtime": mtime})
+                            except Exception:
+                                continue
+
+                    # Selection policy:
+                    # - For .pptx and .ppt: choose the single largest file (assume most complete)
+                    # - For other ext: include all
+                    for ext, items in candidates_by_ext.items():
+                        if ext in (".pptx", ".ppt"):
+                            if items:
+                                best = max(items, key=lambda x: (x.get("size", 0), x.get("mtime", 0.0)))
+                                selected_paths.append(best["path"])
+                        else:
+                            for it in items:
+                                selected_paths.append(it["path"])
 
-                    # Sort newest first and cap to a few uploads to keep fast
-                    recent_files.sort(key=lambda p: os.path.getmtime(p), reverse=True)
-                    recent_files = recent_files[:5]
+                # Upload only selected paths
+                for fp in selected_paths:
+                    try:
+                        up_json = upload_file_to_azure_blob(fp, blob_name=None)
+                        up = json.loads(up_json)
+                        if "download_url" in up and "blob_name" in up:
+                            uploaded_file_urls[up["blob_name"]] = up["download_url"]
+                            try:
+                                bname = os.path.basename(str(up.get("blob_name") or ""))
+                                extl = os.path.splitext(bname)[1].lower()
+                                is_img = extl in (".png", ".jpg", ".jpeg", ".webp", ".gif")
+                                uploaded_files_list.append({
+                                    "file_name": bname,
+                                    "url": up["download_url"],
+                                    "ext": extl,
+                                    "is_image": is_img,
+                                })
+                                if is_img:
+                                    external_media_urls.append(up["download_url"])
+                            except Exception:
+                                pass
+                    except Exception:
+                        continue
+            except Exception:
+                pass
 
-                    for fp in recent_files:
-                        try:
-                            up_json = upload_file_to_azure_blob(fp, blob_name=None)
-                            up = json.loads(up_json)
-                            if "download_url" in up and "blob_name" in up:
-                                uploaded_file_urls[up["blob_name"]] = up["download_url"]
-                                final_result_content.append(f"Uploaded file: [{up['blob_name']}]({up['download_url']})")
-                        except Exception:
-                            continue
+            # Deduplicate and cap external media to a reasonable number
+            try:
+                dedup_media = []
+                seen = set()
+                for u in external_media_urls:
+                    if u in seen:
+                        continue
+                    seen.add(u)
+                    dedup_media.append(u)
+                external_media_urls = dedup_media[:24]
             except Exception:
                 pass
 
             result_limited_to_fit = "\n".join(final_result_content)
 
-            presenter_task = f"""
-            Present the task result in a great way, Markdown, it'll be shown in a React app that supports markdown that doesn't have access to your local files.
-            Make sure to use all the info you have, do not miss any info.
-            Make sure to have images, videos, etc. users love them.
-            UI must be professional that is really important.
+            # Provide the presenter with explicit file list to avoid duplication and downloads sections
+            uploaded_files_list = []
+            try:
+                for blob_name, url in (uploaded_file_urls.items() if isinstance(uploaded_file_urls, dict) else []):
+                    try:
+                        fname = os.path.basename(str(blob_name))
+                    except Exception:
+                        fname = str(blob_name)
+                    extl = os.path.splitext(fname)[1].lower()
+                    is_image = extl in (".png", ".jpg", ".jpeg", ".webp", ".gif")
+                    uploaded_files_list.append({"file_name": fname, "url": url, "ext": extl, "is_image": is_image})
+            except Exception:
+                pass
 
-            TASK: 
+            presenter_task = f"""
+            Present the task result in a clean, professional Markdown/HTML that contains ONLY what the task requested. This will be shown in a React app.
+            Use only the information provided.
 
+            TASK:
             {task}
 
             RAW_AGENT_COMMUNICATIONS:
-
             {result_limited_to_fit}
 
             UPLOADED_FILES_SAS_URLS:
-
             {json.dumps(uploaded_file_urls, indent=2)}
 
-            **CRITICAL INSTRUCTION: Analyze the RAW_AGENT_COMMUNICATIONS above. Your ONLY goal is to extract and present the final, user-facing result requested in the TASK. Absolutely DO NOT include any code, internal agent thought processes, tool calls, technical logs, or descriptions of how the task was accomplished. Focus solely on delivering the ANSWER to the user's original request in a clear, professional, and visually appealing Markdown format. If the task was to create a file, you MUST ONLY use download URLs found in UPLOADED_FILES_SAS_URLS. DO NOT fabricate, guess, or link to any external or placeholder URLs. If no uploaded URLs exist, say so and present the results without a download link. Remove all extraneous information.**
+            EXTERNAL_MEDIA_URLS:
+            {json.dumps(external_media_urls, indent=2)}
+
+            UPLOADED_FILES_LIST:
+            {json.dumps(uploaded_files_list, indent=2)}
+
+            STRICT OUTPUT RULES:
+            - Use UPLOADED_FILES_LIST (SAS URLs) and EXTERNAL_MEDIA_URLS to present assets. Always use the SAS URL provided in UPLOADED_FILES_LIST for any uploaded file.
+            - Images (png, jpg, jpeg, webp, gif): embed inline in a Visuals section using <figure><img/></figure> with captions. Do NOT provide links for images.
+            - Non-image files (pptx, pdf, csv): insert a SINGLE inline anchor (<a href=\"...\">filename</a>) at the first natural mention; do NOT create a 'Downloads' section; do NOT repeat links.
+            - For media: do NOT use grid or containers.
+              - SINGLE media: wrap in <figure style=\"margin: 12px 0;\"> with <img style=\"display:block;width:100%;max-width:960px;height:auto;margin:0 auto;border-radius:8px;box-shadow:0 1px 3px rgba(0,0,0,0.12)\"> and a <figcaption style=\"margin-top:8px;font-size:0.92em;color:inherit;opacity:0.8;text-align:center;\">.
+              - MULTIPLE media: output consecutive <figure> elements, one per row; no wrapping <div>.
+            - Avoid framework classes in HTML; rely on inline styles only. Do NOT include any class attributes. Use color: inherit for captions to respect dark/light mode.
+            - Never fabricate URLs, images, or content; use only links present in UPLOADED_FILES_LIST or EXTERNAL_MEDIA_URLS.
+            - Present each uploaded non-image file ONCE only (no duplicate links), using its filename as the link text.
+            - For links, prefer HTML anchor tags: <a href=\"URL\" target=\"_blank\" rel=\"noopener noreferrer\" download>FILENAME</a>.
+            - Do NOT include code, tool usage, or internal logs.
+            - Be detailed and user-facing. Include Overview, Visuals, Key Takeaways, and Next Actions sections. Do not create a Downloads section.
             """
             
             presenter_stream = presenter_agent.run_stream(task=presenter_task)
@@ -375,20 +646,50 @@ Generate only the progress update:"""
             last_message = task_result.messages[-1]
             text_result = last_message.content if hasattr(last_message, 'content') else None
 
-            # Safety check: if presenter fabricated an external link while uploaded_file_urls is empty, replace with explicit notice
+            # No presenter normalization or auto-upload based on text; rely on strict prompts
             try:
-                if not uploaded_file_urls and isinstance(text_result, str):
-                    # naive pattern for http links
-                    import re
-                    if re.search(r"https?://", text_result):
-                        logger.warning("Presenter output contains a link but no uploaded URLs exist. Rewriting to prevent hallucinated links.")
-                        text_result = re.sub(r"\(https?://[^)]+\)", "(Download not available)", text_result)
+                pass
             except Exception:
                 pass
 
+            # No post-sanitization here; enforce via presenter prompt only per user request
+
             logger.info(f"🔍 TASK RESULT:\n{text_result}")
+
+            # Run terminator agent once presenter has produced final text
+            try:
+                term_messages = []
+                term_task = f"""
+                Check if the task is completed and output TERMINATE if and only if done.
+                Latest presenter output:
+                {text_result}
+
+                Uploaded files (SAS URLs):
+                {json.dumps(uploaded_file_urls, indent=2)}
+
+                TASK:
+                {task}
+
+                Reminder:
+                - If the TASK explicitly requires downloadable files, ensure at least one clickable download URL is present.
+                - If the TASK does not require files (e.g., simple answer, calculation, summary, troubleshooting), terminate when the presenter has clearly delivered the requested content. Do not require downloads in that case.
+                """
+                term_stream = terminator_agent.run_stream(task=term_task)
+                async for message in term_stream:
+                    term_messages.append(message)
+                if term_messages:
+                    t_last = term_messages[-1].messages[-1]
+                    t_text = t_last.content if hasattr(t_last, 'content') else ''
+                    logger.info(f"🛑 TERMINATOR: {t_text}")
+                    # If it didn't say TERMINATE but we already have presenter output, proceed anyway
+            except Exception as e:
+                logger.warning(f"⚠️ Terminator agent failed or unavailable: {e}")
             final_data = text_result or "🎉 Your task is complete!"
             await self.progress_tracker.publish_progress(task_id, 1.0, "🎉 Your task is complete!", data=final_data)
+            try:
+                await self.progress_tracker.mark_final(task_id)
+            except Exception:
+                pass
             self.final_progress_sent = True
             
             return text_result
@@ -399,6 +700,21 @@ Generate only the progress update:"""
 
     async def close(self):
         """Close all connections gracefully."""
+        # Stop background progress worker first to avoid pending task destruction
+        try:
+            if self._progress_worker_task is not None:
+                try:
+                    self._progress_worker_task.cancel()
+                    try:
+                        await self._progress_worker_task
+                    except asyncio.CancelledError:
+                        pass
+                finally:
+                    self._progress_worker_task = None
+            # Allow GC of the queue
+            self._progress_queue = None
+        except Exception as e:
+            logger.debug(f"Error stopping progress worker: {e}")
         clients_to_close = [
             self.o3_model_client,
             self.o4_mini_model_client,