from __future__ import annotations import json import secrets import time import traceback from dataclasses import dataclass from typing import Any, Callable import gradio as gr from shared.deepy.config import ( DEEPY_ENABLED_KEY, DEEPY_VRAM_MODE_KEY, DEEPY_VRAM_MODE_UNLOAD, deepy_available, deepy_requirement_met, normalize_deepy_enabled, normalize_deepy_vram_mode, set_deepy_runtime_config, ) from shared.deepy import ui_settings as deepy_ui_settings from shared.deepy.debug_bootstrap import deepy_log_scope from shared.deepy.engine import ( AssistantEngine, AssistantRuntimeHooks, begin_assistant_turn, build_interruption_notice, clear_assistant_session, get_or_create_assistant_session, mark_assistant_turn_message, record_interruption_history, request_assistant_interrupt, request_assistant_reset, set_assistant_debug, set_assistant_tool_ui_settings, tools as AssistantTools, ) from shared.gradio import assistant_chat from shared.utils.thread_utils import AsyncStream, async_run_in _DEEPY_GPU_PROCESS_ID = "deepy" _DEEPY_REQUIREMENT_TEXT = "Deepy requires Prompt Enhancer to be set to Qwen3.5VL Abliterated 4B or 9B." _DEEPY_DISABLED_TEXT = "Deepy is disabled in Configuration > Deepy." @dataclass(slots=True) class DeepyDeps: get_server_config: Callable[[], dict[str, Any]] get_server_config_filename: Callable[[], str] get_verbose_level: Callable[[], int] resolve_prompt_enhancer_settings: Callable[..., tuple[Any, int]] get_state_model_type: Callable[[Any], str] get_model_def: Callable[[str], Any] ensure_prompt_enhancer_loaded: Callable[..., tuple[Any, Any]] unload_prompt_enhancer_runtime: Callable[[], None] get_image_caption_model: Callable[[], Any] get_image_caption_processor: Callable[[], Any] get_enhancer_offloadobj: Callable[[], Any] acquire_gpu: Callable[[Any], None] release_gpu: Callable[..., None] register_gpu_resident: Callable[..., None] clear_gpu_resident: Callable[[Any], None] get_new_refresh_id: Callable[[], Any] get_gen_info: Callable[[Any], dict[str, Any]] get_processed_queue: Callable[[dict[str, Any]], tuple[list[Any], list[Any], list[Any], list[Any]]] get_output_filepath: Callable[[str, bool, bool], str] record_file_metadata: Callable[..., Any] exec_prompt_enhancer_engine: Callable[..., Any] clear_queue_action: Callable[[Any], Any] def _unload_prompt_enhancer_runtime(prompt_enhancer_image_caption_model, prompt_enhancer_llm_model) -> None: from shared.prompt_enhancer import unload_prompt_enhancer_models unload_prompt_enhancer_models(prompt_enhancer_image_caption_model, prompt_enhancer_llm_model) class DeepyController: def __init__(self, deps: DeepyDeps): self._deps = deps self._active_assistant_session: Any | None = None def get_verbose_level(self) -> int: try: return int(self._deps.get_verbose_level() or 0) except Exception: return 0 def _sync_debug_enabled(self) -> bool: try: debug_enabled = int(self._deps.get_verbose_level() or 0) >= 2 except Exception: debug_enabled = False set_assistant_debug(debug_enabled) return debug_enabled def _server_config(self) -> dict[str, Any]: return self._deps.get_server_config() or {} def _persist_tool_ui_settings(self, normalized: dict[str, Any]) -> None: server_config = self._server_config() server_config_filename = str(self._deps.get_server_config_filename() or "").strip() deepy_ui_settings.store_assistant_tool_ui_settings(server_config, normalized) set_deepy_runtime_config(server_config, server_config_filename) if len(server_config_filename) > 0: with open(server_config_filename, "w", encoding="utf-8") as writer: writer.write(json.dumps(server_config, indent=4)) gr.Info("New Deepy Setting Saved") def _reset_foreign_active_session(self, session) -> bool: active_session = self._active_assistant_session if active_session is None or active_session is session: return False request_assistant_reset(active_session) assistant_chat.reset_session_chat(active_session) active_session.chat_html = "" return True @staticmethod def _find_next_queued_user_message_id(session) -> str: for record in list(session.chat_transcript or []): if not isinstance(record, dict): continue if str(record.get("role", "")).strip().lower() != "user": continue if str(record.get("badge", "")).strip() != "Queued": continue message_id = str(record.get("id", "") or "").strip() if len(message_id) > 0: return message_id return "" def _cancel_next_queued_request(self, session) -> bool: if int(session.queued_job_count or 0) <= 0: return False message_id = self._find_next_queued_user_message_id(session) if len(message_id) == 0: return False user_text = assistant_chat.get_message_content(session, message_id) interruption_notice = build_interruption_notice(user_text) session.queued_job_count = max(0, int(session.queued_job_count or 0) - 1) session.queued_cancel_count = max(0, int(session.queued_cancel_count or 0)) + 1 assistant_chat.set_message_badge(session, message_id, "Interrupted") record_interruption_history(session, user_text, interruption_notice) return True def is_available(self) -> bool: return deepy_available(self._server_config()) def requirement_error_text(self) -> str: server_config = self._server_config() if not deepy_requirement_met(server_config): return _DEEPY_REQUIREMENT_TEXT if not normalize_deepy_enabled(server_config.get(DEEPY_ENABLED_KEY, 0)): return _DEEPY_DISABLED_TEXT return "" def get_vram_mode(self) -> str: server_config = self._server_config() return normalize_deepy_vram_mode(server_config.get(DEEPY_VRAM_MODE_KEY, DEEPY_VRAM_MODE_UNLOAD)) def _ensure_vision_loaded(self, override_profile=None): self._deps.ensure_prompt_enhancer_loaded(override_profile=override_profile) image_caption_model = self._deps.get_image_caption_model() image_caption_processor = self._deps.get_image_caption_processor() if image_caption_model is None or image_caption_processor is None: raise gr.Error("Prompt enhancer vision runtime is not available.") return image_caption_model, image_caption_processor def _unload_weights(self) -> None: enhancer_offloadobj = self._deps.get_enhancer_offloadobj() if enhancer_offloadobj is not None: enhancer_offloadobj.unload_all() def _build_preload_release_callback(self) -> Callable[[], None]: def _release_preloaded_runtime() -> None: try: self._deps.unload_prompt_enhancer_runtime() finally: self._unload_weights() return _release_preloaded_runtime def release_vram(self, state, clear_session_state = False, discard_runtime_snapshot = False): session = get_or_create_assistant_session(state) release_callback = session.release_vram_callback session.release_vram_callback = None session.discard_runtime_snapshot_on_release = bool(discard_runtime_snapshot) self._deps.clear_gpu_resident(state) try: if callable(release_callback): release_callback() finally: if discard_runtime_snapshot: session.runtime_snapshot = None if len(session.rendered_token_ids) == 0: session.pending_replay_reason = "" session.discard_runtime_snapshot_on_release = False if clear_session_state: clear_assistant_session(session) def preload_cli_runtime(self, state, override_profile=None) -> dict[str, Any]: self._sync_debug_enabled() self._deps.clear_gpu_resident(state) self._deps.acquire_gpu(state) keep_resident = False warmed_vllm = False try: model, _tokenizer = self._deps.ensure_prompt_enhancer_loaded(override_profile=override_profile) from shared.prompt_enhancer import qwen35_text if qwen35_text._use_vllm_prompt_enhancer(model): engine = qwen35_text._get_or_create_vllm_engine(model, usage_mode="assistant") engine.reserve_runtime(prompt_len=64, max_tokens=1, cfg_scale=1.0) engine._ensure_llm() llm = getattr(engine, "_llm", None) if llm is None: raise RuntimeError("Assistant NanoVLLM runtime is not available.") llm.model_runner.ensure_runtime_ready() engine.release_runtime_allocations() warmed_vllm = True keep_resident = True return {"status": "ready", "warmed_vllm": warmed_vllm} finally: self._deps.release_gpu( state, keep_resident=keep_resident, release_vram_callback=self._build_preload_release_callback() if keep_resident else None, force_release_on_acquire=True, ) def update_tool_ui_settings(self, state, *, auto_cancel_queue_tasks=None, separate_requests_with_empty_line=None, use_template_properties=None, width=None, height=None, num_frames=None, seed=None, video_with_speech_variant=None, image_generator_variant=None, image_editor_variant=None, video_generator_variant=None, speech_from_description_variant=None, speech_from_sample_variant=None, persist=False): session = get_or_create_assistant_session(state) normalized = set_assistant_tool_ui_settings( session, auto_cancel_queue_tasks=auto_cancel_queue_tasks, separate_requests_with_empty_line=separate_requests_with_empty_line, use_template_properties=use_template_properties, width=width, height=height, num_frames=num_frames, seed=seed, video_with_speech_variant=video_with_speech_variant, image_generator_variant=image_generator_variant, image_editor_variant=image_editor_variant, video_generator_variant=video_generator_variant, speech_from_description_variant=speech_from_description_variant, speech_from_sample_variant=speech_from_sample_variant, ) if persist: self._persist_tool_ui_settings(normalized) return normalized @staticmethod def _split_request_blocks(text: str) -> list[str]: normalized = str(text or "").replace("\r\n", "\n").replace("\r", "\n").strip() if len(normalized) == 0: return [] requests = [] current_lines = [] for raw_line in normalized.split("\n"): if not raw_line.strip(): if current_lines: requests.append("\n".join(current_lines).strip()) current_lines = [] continue current_lines.append(raw_line.rstrip()) if current_lines: requests.append("\n".join(current_lines).strip()) return [request for request in requests if len(request) > 0] def _expand_assistant_requests(self, session, ask_request: Any) -> list[str]: normalized_request = str(ask_request or "").strip() if len(normalized_request) == 0: return [] tool_ui_settings = deepy_ui_settings.normalize_assistant_tool_ui_settings(**session.tool_ui_settings) if isinstance(session.tool_ui_settings, dict) and len(session.tool_ui_settings) > 0 else deepy_ui_settings.get_persisted_assistant_tool_ui_settings(self._server_config()) if not tool_ui_settings["separate_requests_with_empty_line"]: return [normalized_request] return self._split_request_blocks(normalized_request) or [normalized_request] def _queue_assistant_request(self, state, session, output_queue, ask_request: str, queued_epoch: int, *, queued: bool, precreate_assistant_turn: bool = False) -> None: raw_send_cmd = output_queue.push assistant_turn_id = "" def send_cmd(cmd, data=None): if queued_epoch != session.chat_epoch and cmd in {"chat_output", "load_queue_trigger", "refresh_gallery", "error"}: return raw_send_cmd(cmd, data) session.queued_job_count += 1 user_message_id, _user_event = assistant_chat.add_user_message(session, ask_request, queued=queued) if precreate_assistant_turn: assistant_turn_id = assistant_chat.create_assistant_turn(session) def queue_worker_func(): with deepy_log_scope(start_if_needed=True): started_turn = False if queued_epoch != session.chat_epoch: if session.control_queue is output_queue: session.control_queue = None raw_send_cmd("exit", None) return if int(session.queued_cancel_count or 0) > 0: session.queued_cancel_count = max(0, int(session.queued_cancel_count or 0) - 1) assistant_chat.set_message_badge(session, user_message_id, "Interrupted") if session.control_queue is output_queue and session.queued_job_count <= 0: session.control_queue = None raw_send_cmd("chat_output", assistant_chat.build_sync_event(session)) if session.queued_job_count > 0: raw_send_cmd("chat_output", assistant_chat.build_status_event("Queued behind the current assistant task.", kind="queued")) else: raw_send_cmd("chat_output", assistant_chat.build_status_event(None, visible=False)) raw_send_cmd("exit", None) return session.queued_job_count = max(0, session.queued_job_count - 1) session.interrupt_requested = False session.control_queue = output_queue session.worker_active = True self._active_assistant_session = session begin_assistant_turn(session, user_message_id, ask_request) started_turn = True assistant_chat.set_message_badge(session, user_message_id, None) active_turn_id = assistant_turn_id or assistant_chat.create_assistant_turn(session) mark_assistant_turn_message(session, active_turn_id) send_cmd("chat_output", assistant_chat.build_sync_event(session)) my_tools = self.create_tools(state, send_cmd, session=session) try: self._deps.exec_prompt_enhancer_engine(state, "", None, "AK", [ask_request], None, None, False, False, 0, None, 3.5, send_cmd, my_tools) except Exception as e: traceback.print_exc() error_turn_id = assistant_turn_id or assistant_chat.create_assistant_turn(session) error_event = assistant_chat.set_assistant_content(session, error_turn_id, f"Assistant crashed: {e}") if error_event is not None: send_cmd("chat_output", error_event) send_cmd("chat_output", assistant_chat.build_status_event(None, visible=False)) finally: if self._active_assistant_session is session: self._active_assistant_session = None session.worker_active = False stale_turn = queued_epoch != session.chat_epoch has_more_work = not stale_turn and session.queued_job_count > 0 if not has_more_work and session.control_queue is output_queue: session.control_queue = None if stale_turn: if started_turn: raw_send_cmd("chat_output", assistant_chat.build_reset_event()) else: raw_send_cmd("chat_output", assistant_chat.build_sync_event(session)) if has_more_work: raw_send_cmd("chat_output", assistant_chat.build_status_event("Queued behind the current assistant task.", kind="queued")) session.interrupt_requested = False if not has_more_work: raw_send_cmd("exit", None) async_run_in("assistant", queue_worker_func) def store_selected_video_time(self, state, current_time): gen = self._deps.get_gen_info(state) try: value = float(current_time) except Exception: value = None gen["selected_video_time"] = None if value is None or value < 0 else value def create_tools(self, state, send_cmd, session = None): active_session = get_or_create_assistant_session(state) if session is None else session gen = self._deps.get_gen_info(state) return AssistantTools( gen, self._deps.get_processed_queue, send_cmd, session=active_session, get_output_filepath=self._deps.get_output_filepath, record_file_metadata=self._deps.record_file_metadata, get_server_config=self._server_config, ) def run_assistant_prompt_turn(self, state, model_def, prompt_enhancer_modes, original_prompts, seed, override_profile=None, send_cmd=None, tools=None) -> None: debug_enabled = self._sync_debug_enabled() server_config = self._server_config() if not normalize_deepy_enabled(server_config.get(DEEPY_ENABLED_KEY, 0)): raise gr.Error(_DEEPY_DISABLED_TEXT) if not deepy_requirement_met(server_config): raise gr.Error(_DEEPY_REQUIREMENT_TEXT) if send_cmd is None or tools is None: raise gr.Error("Assistant mode requires a command stream and a tool registry.") enhancer_temperature = server_config.get("prompt_enhancer_temperature", 0.6) enhancer_top_p = server_config.get("prompt_enhancer_top_p", 0.9) randomize_seed = server_config.get("prompt_enhancer_randomize_seed", True) assistant_seed = secrets.randbits(32) if randomize_seed else (seed if seed is not None and seed >= 0 else 0) session = get_or_create_assistant_session(state) assistant_model_def = model_def _assistant_instructions, assistant_max_new_tokens = self._deps.resolve_prompt_enhancer_settings("", assistant_model_def, prompt_enhancer_modes, is_image=False, text_encoder_max_tokens=1024) assistant = AssistantEngine( session, AssistantRuntimeHooks( acquire_gpu=lambda: self._deps.acquire_gpu(state), release_gpu=lambda keep_resident = False, release_vram_callback = None, force_release_on_acquire = True: self._deps.release_gpu(state, keep_resident=keep_resident, release_vram_callback=release_vram_callback, force_release_on_acquire=force_release_on_acquire), register_gpu_resident=lambda release_vram_callback = None, force_release_on_acquire = True: self._deps.register_gpu_resident(state, release_vram_callback=release_vram_callback, force_release_on_acquire=force_release_on_acquire), clear_gpu_resident=lambda: self._deps.clear_gpu_resident(state), ensure_loaded=lambda: self._deps.ensure_prompt_enhancer_loaded(override_profile=override_profile), unload_runtime=self._deps.unload_prompt_enhancer_runtime, unload_weights=self._unload_weights, ensure_vision_loaded=lambda: self._ensure_vision_loaded(override_profile=override_profile), ), tools, send_cmd, debug_enabled=debug_enabled, thinking_enabled="K" in prompt_enhancer_modes, vram_mode=self.get_vram_mode(), ) with deepy_log_scope(start_if_needed=debug_enabled): assistant.run_turn( original_prompts[0] if len(original_prompts) > 0 else "", max_new_tokens=max(1024, int(assistant_max_new_tokens)), seed=assistant_seed, do_sample=True, temperature=enhancer_temperature, top_p=enhancer_top_p, ) def ask_ai(self, state, ask_request): self._sync_debug_enabled() def get_refresh_id(): return str(time.time()) + "_" + str(self._deps.get_new_refresh_id()) def drain_chat_output_batch(first_payload): payloads = [first_payload] while True: next_item = com_stream.output_queue.top() if not isinstance(next_item, tuple) or len(next_item) < 1 or next_item[0] != "chat_output": break _cmd, next_payload = com_stream.output_queue.pop() payloads.append(next_payload) return assistant_chat.build_event_batch(payloads) session = get_or_create_assistant_session(state) foreign_session_reset = self._reset_foreign_active_session(session) request_blocks = self._expand_assistant_requests(session, ask_request) if len(request_blocks) == 0: yield gr.update(), gr.update(), gr.update(), gr.update(), gr.update() return if session.drop_state_requested: yield assistant_chat.build_status_event("Resetting after the current work stops...", kind="queued"), gr.update(), gr.update(value=""), gr.update(), gr.update() return if not self.is_available(): error_turn_id = assistant_chat.create_assistant_turn(session) error_event = assistant_chat.set_assistant_content(session, error_turn_id, self.requirement_error_text()) yield error_event if error_event is not None else gr.update(), gr.update(), gr.update(value=""), gr.update(), gr.update() return com_stream = AsyncStream() output_queue = com_stream.output_queue queued = foreign_session_reset or session.worker_active or session.queued_job_count > 0 queued_epoch = session.chat_epoch for index, request_block in enumerate(request_blocks): self._queue_assistant_request(state, session, output_queue, request_block, queued_epoch, queued=queued or index > 0, precreate_assistant_turn=not queued and index == 0 and len(request_blocks) > 1) yield assistant_chat.build_sync_event(session), gr.update(), gr.update(value=""), gr.update(), gr.update() if queued or len(request_blocks) > 1: yield assistant_chat.build_status_event("Queued behind the current assistant task.", kind="queued"), gr.update(), gr.update(), gr.update(), gr.update() while True: cmd, data = com_stream.output_queue.next() if cmd == "console_output": print(data) elif cmd == "chat_output": yield drain_chat_output_batch(data), gr.update(), gr.update(), gr.update(), gr.update() elif cmd == "load_queue_trigger": yield gr.update(), str(get_refresh_id()), gr.update(), gr.update(), gr.update() elif cmd == "abort_client_id": yield gr.update(), gr.update(), gr.update(), gr.update(), str(data or "") elif cmd == "refresh_gallery": yield gr.update(), gr.update(), gr.update(), str(get_refresh_id()), gr.update() elif cmd == "error": error_turn_id = assistant_chat.create_assistant_turn(session) error_event = assistant_chat.set_assistant_content(session, error_turn_id, str(data or "Assistant error.")) yield error_event if error_event is not None else gr.update(), gr.update(), gr.update(), gr.update(), gr.update() elif cmd == "exit": break def enqueue_ai_while_busy(self, state, ask_request): self._sync_debug_enabled() session = get_or_create_assistant_session(state) request_blocks = self._expand_assistant_requests(session, ask_request) if len(request_blocks) == 0: return gr.update(), gr.update(value="") if session.drop_state_requested: return assistant_chat.build_status_event("Resetting after the current work stops...", kind="queued"), gr.update(value="") if not self.is_available(): if session.control_queue is not None: error_turn_id = assistant_chat.create_assistant_turn(session) error_event = assistant_chat.set_assistant_content(session, error_turn_id, self.requirement_error_text()) if error_event is not None: session.control_queue.push("chat_output", error_event) return gr.update(), gr.update(value="") output_queue = session.control_queue if output_queue is None or (not session.worker_active and session.queued_job_count <= 0): return gr.update(), gr.update(value="") queued_epoch = session.chat_epoch for request_block in request_blocks: self._queue_assistant_request(state, session, output_queue, request_block, queued_epoch, queued=True) output_queue.push("chat_output", assistant_chat.build_sync_event(session)) output_queue.push("chat_output", assistant_chat.build_status_event("Queued behind the current assistant task.", kind="queued")) return gr.update(), gr.update(value="") def stop_ai(self, state): session = get_or_create_assistant_session(state) if session.worker_active: if session.interrupt_requested and self._cancel_next_queued_request(session): return assistant_chat.build_sync_event(session), gr.update(), gr.update(), gr.update() request_assistant_interrupt(session) return assistant_chat.build_status_event("Interrupting the current assistant task...", kind="queued"), gr.update(), gr.update(), gr.update() if not session.worker_active and self._cancel_next_queued_request(session): chat_event = assistant_chat.build_sync_event(session) return chat_event, gr.update(), gr.update(), gr.update() return gr.update(), gr.update(), gr.update(), gr.update() def reset_ai(self, state): session = get_or_create_assistant_session(state) if session.worker_active: print("[Assistant] Reset requested during an active turn; the chat will reset after the current work stops.") request_assistant_reset(session) session.chat_html = "" return assistant_chat.build_status_event("Resetting after the current work stops...", kind="queued"), gr.update(), gr.update(value=""), gr.update() else: reset_to_base_callback = session.reset_to_base_callback reset_applied = False if callable(reset_to_base_callback): try: reset_applied = bool(reset_to_base_callback()) except Exception as exc: print(f"[Assistant] Idle reset-base reuse failed: {exc}") reset_applied = False if reset_applied: print("[Assistant] Idle Reset: reused preserved header snapshot. [no prefill redone]") if not reset_applied: print("[Assistant] Idle Reset: fallback to full clear.") self.release_vram(state, True) session.chat_html = "" return assistant_chat.build_reset_event(), gr.update(), gr.update(value=""), gr.update() def browser_session_started(self, state): session = get_or_create_assistant_session(state) if self._reset_foreign_active_session(session): return assistant_chat.build_reset_event(), gr.update(), gr.update(value=""), gr.update() if not session.worker_active and session.queued_job_count <= 0: return gr.update(), gr.update(), gr.update(), gr.update() request_assistant_reset(session) session.chat_html = "" return assistant_chat.build_status_event("Resetting after the current work stops...", kind="queued"), gr.update(), gr.update(value=""), gr.update() def create_controller(**deps_kwargs) -> DeepyController: return DeepyController(DeepyDeps(**deps_kwargs))