سلام من یک چت بات درست کردم در اسپیس هاگینگ فیس. د...

عالیه—فایل‌ها رسید و آماده‌ام هر کاری گفتی انجام بدم. 👌
برای اینکه مطمئن باشی دقیق متوجه شدم، یه خلاصه خیلی سریع از ساختار الان:

• داکرفایل: پایتون ۳.۹ اسلیم، نصب requirements.txt، اجرای اپ با Gunicorn (۵ ورکِر gevent، پورت ۷۸۶۰، تایم‌اوت ۷۲۰ ثانیه). (Dockerfile (4).txt)
• بک‌اند فلask:
  • لاگینگ فارسی، گرفتن کلیدها از ALL_GEMINI_API_KEYS و چرخشی‌شون با شمارنده در /dev/shm.
  • کش فایل‌ها و متادیتای چت‌ها در /dev/shm؛ اگر کاربر فایل فرستاده باشه ذخیره می‌شه و اگر پیام بعدی فایل نداشت، از کش دوباره به پیام تزریق می‌کنی.
  • روترها: GET / برای رندر index.html و POST /chat با استریم پاسخ (مدل‌های Gemini، طبقه‌بندی نیت، تحلیل فایل، تولید/ادیت تصویر…). (app (31).py)
• وابستگی‌ها: Flask, Gunicorn, gevent, requests, sseclient, filelock و… (requirements (1) (7).txt)
• فرانت‌اند (HTML): UI فارسی با Tailwind، تاریخچه چت، تم روشن/تاریک، ورودی فایل «عمومی» (اکسپت حذف شده تا همه‌ی فرمت‌ها قابل انتخاب باشن). (index (12).html)
• ماژول API سمت کلاینت: آپلود فایل به یک Space آپلودر HF، دائمی‌سازی لینک، تبدیل متن↔️PDF/Docx روی سرور خارجی، هدایت ساخت/ادیت تصویر (Flux HF و یک ورکر رندر). همچنین قبل از ارسال، تاریخچه رو خلاصه و نوع فایل رو به مدل یادآوری می‌کنه. (api (19).js)
• منطق اصلی فرانت: مدیریت جلسات چت در localStorage (مدل پیش‌فرض: gemini-1.5-pro-latest)، ارسال پیام‌ها/فایل‌ها، ری‌جنریت، ادیت آخرین پیام کاربر، و هندل رویدادهای UI. (main (14).js)
• وضعیت اپ: نگهداری سشن‌ها، محدودیت ۱۵۰ چت، حذف base64Data قبل از ذخیره در مرورگر. (state (4).js)
• UI کمکی: رندر پیام‌ها، اکشن‌ها (کپی/دانلود/لایک/دیس‌لایک/ری‌جنریت)، نمایش گالری تصویر، پیش‌نمایش/پروگرس آپلود، و هندلینگ خطا (از جمله راهنمای محدودیت GPU). (ui (9).js)

هر زمان گفتی، نسخه‌ی «ذخیره در دیتاست هاگینگ‌فیس» رو هم برات جایگزین/موازی می‌کنم (طراحی اسکیمای دیتاست، endpointهای جدید، همگام‌سازی تاریخچه‌ها و نکات امنیت/Rate-limit). بفرما دستور بعدی چیه؟ 😊

app.py

python
import os, json, time, base64
from io import BytesIO
import requests
from flask import Flask, request, render_template, Response, jsonify
from huggingface_hub import HfApi, hf_hub_download
import google.generativeai as genai

app = Flask(__name__, static_folder='static', template_folder='templates')

HF_TOKEN = os.getenv('HF_TOKEN', '')
HF_DATASET_REPO = os.getenv('HF_DATASET_REPO', '')
ALL_KEYS = [k.strip() for k in os.getenv('ALL_GEMINI_API_KEYS', '').split(',') if k.strip()]

hf_api = HfApi(token=HF_TOKEN)
_key_index = 0

def ensure_repo():
    if not HF_DATASET_REPO:
        raise RuntimeError('HF_DATASET_REPO is not set')
    try:
        hf_api.create_repo(repo_id=HF_DATASET_REPO, repo_type='dataset', exist_ok=True)
    except Exception:
        pass

def chat_file_path(chat_id):
    return f"chats/{chat_id}.jsonl"

def read_chat(chat_id):
    ensure_repo()
    path_in_repo = chat_file_path(chat_id)
    try:
        local_path = hf_hub_download(repo_id=HF_DATASET_REPO, filename=path_in_repo, repo_type='dataset', token=HF_TOKEN, local_dir='/tmp', force_download=True)
        with open(local_path, 'r', encoding='utf-8') as f:
            lines = [json.loads(l) for l in f.read().splitlines() if l.strip()]
        return lines
    except Exception:
        return []

def write_chat_full(chat_id, items):
    ensure_repo()
    local_tmp = f"/tmp/{chat_id}.jsonl"
    with open(local_tmp, 'w', encoding='utf-8') as f:
        for it in items:
            f.write(json.dumps(it, ensure_ascii=False) + '\n')
    hf_api.upload_file(path_or_fileobj=local_tmp, path_in_repo=chat_file_path(chat_id), repo_id=HF_DATASET_REPO, repo_type='dataset', commit_message=f"update chat {chat_id}")

def append_chat(chat_id, record):
    items = read_chat(chat_id)
    items.append(record)
    write_chat_full(chat_id, items)

def rotate_key():
    global _key_index
    if not ALL_KEYS:
        raise RuntimeError('ALL_GEMINI_API_KEYS is not set')
    key = ALL_KEYS[_key_index % len(ALL_KEYS)]
    _key_index += 1
    genai.configure(api_key=key)

def get_model(name):
    rotate_key()
    return genai.GenerativeModel(name)

def to_genai_parts(parts):
    out = []
    for p in parts or []:
        if 'text' in p:
            out.append(p['text'])
        elif 'inlineData' in p:
            d = p['inlineData']
            try:
                data = base64.b64decode(d.get('data', ''))
            except Exception:
                data = b''
            out.append({'mime_type': d.get('mimeType', 'application/octet-stream'), 'data': data})
        elif 'fileUrl' in p:
            url = p['fileUrl']
            try:
                r = requests.get(url, timeout=20)
                if r.ok:
                    mime = p.get('mimeType') or r.headers.get('content-type', 'application/octet-stream')
                    out.append({'mime_type': mime, 'data': r.content})
            except Exception:
                pass
    return out

def detect_intent(text, parts):
    t = (text or '').strip()
    fa = t
    has_file = any(('fileUrl' in p) or ('inlineData' in p) for p in parts or [])
    if any(w in fa for w in ['ویرایش', 'ادیت', 'بازطراحی', 'دوباره طراحی']) and has_file:
        return {'intent': 'edit_image', 'prompt': t}
    if any(w in fa for w in ['تصویر', 'عکس']) and any(w in fa for w in ['بساز', 'تولید', 'ایجاد', 'بکش', 'طراحی کن']):
        ratio = '9:16'
        for r in ['16:9', '9:16', '1:1', '4:3', '3:4', '3:2', '2:3', 'افقی', 'عمودی', 'مربع']:
            if r in fa:
                ratio = r
                break
        eng = t
        try:
            m = get_model('gemini-1.5-flash')
            tr = m.generate_content(f"Translate this prompt to concise English for image generation. Keep proper nouns and style terms:\n{t}")
            if tr and getattr(tr, 'text', None):
                eng = tr.text.strip()
        except Exception:
            pass
        return {'intent': 'generate_image', 'english_prompt': eng, 'aspect_ratio': ratio}
    return None

def sse(data):
    return f"data: {json.dumps(data, ensure_ascii=False)}\n\n"

@app.route('/chat', methods=['POST'])
def chat():
    data = request.get_json(force=True)
    chat_id = data.get('chatId') or str(int(time.time()*1000))
    model_name = data.get('model') or 'gemini-1.5-pro-latest'
    new_user = data.get('newUserMessage')
    history_override = data.get('history')
    action = data.get('action')

    if new_user:
        append_chat(chat_id, {'ts': int(time.time()*1000), 'role': 'user', 'parts': new_user.get('parts', [])})

    user_text = ''
    user_parts = []
    if new_user:
        user_parts = new_user.get('parts', [])
        for p in user_parts:
            if 'text' in p:
                user_text += p['text'] + '\n'

    if action and action.get('intent') == 'regenerate_with_enhancement':
        user_text += '\n' + action.get('enhancement', '')

    intent_payload = detect_intent(user_text, user_parts)

    def stream():
        try:
            if intent_payload:
                yield sse(intent_payload)
                return
            msgs = history_override if history_override else read_chat(chat_id)
            contents = []
            for m in msgs:
                if m.get('role') == 'user':
                    contents += to_genai_parts(m.get('parts', []))
                elif m.get('role') == 'model':
                    text_acc = ''
                    for pr in m.get('parts', []):
                        if 'text' in pr:
                            text_acc += pr['text']
                    if text_acc:
                        contents.append(text_acc)
            if new_user:
                contents += to_genai_parts(new_user.get('parts', []))
            model = get_model(model_name)
            resp = model.generate_content(contents, stream=True)
            full_text = ''
            for chunk in resp:
                t = getattr(chunk, 'text', None)
                if t:
                    full_text += t
                    yield sse({'candidates': [{'content': {'parts': [{'text': t}]}}]})
            if full_text:
                append_chat(chat_id, {'ts': int(time.time()*1000), 'role': 'model', 'parts': [{'text': full_text}]})
        except Exception as e:
            yield sse({'error': {'message': str(e)}})
    return Response(stream(), mimetype='text/event-stream')

@app.route('/history/<chat_id>')
def history_route(chat_id):
    return jsonify(read_chat(chat_id))

@app.route('/')
def index():
    return render_template('index.html')

requirements.txt

text
Flask==2.2.2
Werkzeug==2.2.2
gunicorn==20.1.0
requests
gevent==22.10.2
sseclient-py==1.8.0
filelock==3.13.1
huggingface_hub==0.23.4
datasets==2.20.0
pandas==2.2.2
pyarrow==16.1.0
google-generativeai==0.5.2

state.js

javascript
export let chatSessions = [];
export let activeChatId = null;
export let attachedFile = null;
export let isGenerating = false;
export let currentUploadXHR = null;
export let currentImageEventSource = null;
export let globalAbortController = null;
let gpuGuideVisible = false;

const SESSIONS_KEY = 'alpha_chat_sessions_v2';
const ACTIVE_KEY = 'alpha_active_chat_id_v2';

export function loadSessions() {
    try {
        const s = localStorage.getItem(SESSIONS_KEY);
        chatSessions = s ? JSON.parse(s) : [];
        activeChatId = localStorage.getItem(ACTIVE_KEY) || (chatSessions[0]?.id || null);
    } catch (e) {
        chatSessions = [];
        activeChatId = null;
    }
}

export function saveSessions() {
    try {
        const sessionsToSave = chatSessions.map(s => {
            const sanitized = { ...s, messages: (s.messages || []).map(m => {
                const parts = (m.parts || []).map(p => {
                    const q = { ...p };
                    if (q.base64Data) delete q.base64Data;
                    return q;
                });
                return { ...m, parts };
            }) };
            return sanitized;
        });
        localStorage.setItem(SESSIONS_KEY, JSON.stringify(sessionsToSave));
        if (activeChatId) localStorage.setItem(ACTIVE_KEY, activeChatId);
    } catch (e) {}
}

export function setChatSessions(arr) {
    chatSessions = Array.isArray(arr) ? arr : [];
}

export function setActiveChatId(id) {
    activeChatId = id;
    if (id) localStorage.setItem(ACTIVE_KEY, id); else localStorage.removeItem(ACTIVE_KEY);
}

export function getActiveChat() {
    return chatSessions.find(s => s.id === activeChatId) || null;
}

export function deleteChat(id) {
    chatSessions = chatSessions.filter(s => s.id !== id);
    saveSessions();
}

export function findLastIndex(arr, predicate) {
    if (!Array.isArray(arr)) return -1;
    for (let i = arr.length - 1; i >= 0; i--) {
        if (predicate(arr[i])) return i;
    }
    return -1;
}

export function setAttachedFile(fileObj) {
    attachedFile = fileObj;
}

export function setGpuGuideState(v) {
    gpuGuideVisible = !!v;
}

export function setCurrentImageEventSource(es) {
    currentImageEventSource = es;
}

export function setGeneratingState(v) {
    isGenerating = !!v;
    globalAbortController = v ? new AbortController() : null;
}

export function updateLastUserMessageWithImageGenData(chatId, englishPrompt, aspectRatio) {
    const chat = chatSessions.find(s => s.id === chatId);
    if (!chat) return;
    for (let i = chat.messages.length - 1; i >= 0; i--) {
        const msg = chat.messages[i];
        if (msg.role === 'user') {
            msg.image_generation_payload = { english_prompt: englishPrompt, aspect_ratio: aspectRatio };
            break;
        }
    }
    saveSessions();
}

(api (20).js)
(ui (10).js)
(requirements (1) (8).txt)

app.py

python
import os, json, time, base64, re, mimetypes, hashlib
from io import BytesIO
import requests
from flask import Flask, request, render_template, Response, jsonify
from huggingface_hub import HfApi, hf_hub_download
import google.generativeai as genai

app = Flask(__name__, static_folder='static', template_folder='templates')

HF_TOKEN = os.getenv('HF_TOKEN', '')
HF_DATASET_REPO = os.getenv('HF_DATASET_REPO', '')
ALL_KEYS = [k.strip() for k in os.getenv('ALL_GEMINI_API_KEYS', '').split(',') if k.strip()]

hf_api = HfApi(token=HF_TOKEN)
_key_index = 0

def ensure_repo():
    if not HF_DATASET_REPO:
        raise RuntimeError('HF_DATASET_REPO is not set')
    try:
        hf_api.create_repo(repo_id=HF_DATASET_REPO, repo_type='dataset', exist_ok=True)
    except Exception:
        pass

def chat_file_path(chat_id):
    return f"chats/{chat_id}.jsonl"

def read_chat(chat_id):
    ensure_repo()
    path_in_repo = chat_file_path(chat_id)
    try:
        local_path = hf_hub_download(repo_id=HF_DATASET_REPO, filename=path_in_repo, repo_type='dataset', token=HF_TOKEN, local_dir='/tmp', force_download=True)
        with open(local_path, 'r', encoding='utf-8') as f:
            return [json.loads(l) for l in f.read().splitlines() if l.strip()]
    except Exception:
        return []

def write_chat_full(chat_id, items):
    ensure_repo()
    local_tmp = f"/tmp/{chat_id}.jsonl"
    with open(local_tmp, 'w', encoding='utf-8') as f:
        for it in items:
            f.write(json.dumps(it, ensure_ascii=False) + '\n')
    hf_api.upload_file(path_or_fileobj=local_tmp, path_in_repo=chat_file_path(chat_id), repo_id=HF_DATASET_REPO, repo_type='dataset', commit_message=f"update chat {chat_id}")

def append_chat(chat_id, record):
    items = read_chat(chat_id)
    items.append(record)
    write_chat_full(chat_id, items)

def rotate_key():
    global _key_index
    if not ALL_KEYS:
        raise RuntimeError('ALL_GEMINI_API_KEYS is not set')
    key = ALL_KEYS[_key_index % len(ALL_KEYS)]
    _key_index += 1
    genai.configure(api_key=key)

def get_model(name):
    rotate_key()
    return genai.GenerativeModel(name)

def fetch_url_bytes(url, timeout=20):
    try:
        r = requests.get(url, timeout=timeout)
        if r.ok:
            mime = r.headers.get('content-type', 'application/octet-stream').split(';')[0].strip()
            return r.content, mime
    except Exception:
        return None, None
    return None, None

def to_genai_parts(parts):
    out = []
    for p in parts or []:
        if 'text' in p and p['text']:
            out.append(p['text'])
        elif 'inlineData' in p:
            d = p['inlineData'] or {}
            data_b64 = d.get('data', '')
            try:
                data = base64.b64decode(data_b64)
            except Exception:
                data = b''
            mime = d.get('mimeType') or 'application/octet-stream'
            out.append({'mime_type': mime, 'data': data})
        elif 'fileUrl' in p and p['fileUrl']:
            data, mime = fetch_url_bytes(p['fileUrl'])
            if data:
                out.append({'mime_type': mime or p.get('mimeType') or 'application/octet-stream', 'data': data})
    return out

def normalize_text(t):
    return (t or '').replace('\u200c', ' ').replace('\xa0', ' ').strip()

def has_file(parts):
    for p in parts or []:
        if p.get('fileUrl') or p.get('inlineData'):
            return True
    return False

def persian_contains_any(text, words):
    t = normalize_text(text)
    for w in words:
        if w in t:
            return True
    return False

def extract_aspect_ratio(text):
    t = normalize_text(text)
    ratios = ['16:9', '9:16', '1:1', '4:3', '3:4', '3:2', '2:3']
    for r in ratios:
        if r in t:
            return r
    if 'افقی' in t:
        return '16:9'
    if 'عمودی' in t:
        return '9:16'
    if 'مربع' in t:
        return '1:1'
    return '9:16'

def translate_to_english(prompt):
    try:
        m = get_model('gemini-1.5-flash')
        r = m.generate_content(f"Translate this prompt to concise English for image generation. Keep proper nouns and style words. No extra commentary:\n{prompt}")
        if r and getattr(r, 'text', None):
            return r.text.strip()
    except Exception:
        return prompt
    return prompt

def detect_intent(user_text, user_parts):
    t = normalize_text(user_text)
    file_attached = has_file(user_parts)
    if persian_contains_any(t, ['ویرایش', 'ادیت', 'بازطراحی', 'دوباره طراحی', 'بهبود تصویر', 'اصلاح تصویر']):
        if file_attached:
            return {'intent': 'edit_image', 'prompt': t}
        return {
            'intent': 'clarify_action',
            'question': 'می‌خواهی تصویر را ویرایش کنم یا پاسخ متنی را بهتر بنویسم؟',
            'options': {
                'edit': {'intent': 'edit_image', 'prompt': t, 'label': 'ویرایش تصویر'},
                'regenerate': {'intent': 'regenerate_with_enhancement', 'enhancement': 'پاسخ را با جزئیات و مثال‌های بهتر بازنویسی کن.', 'label': 'بازنویسی پاسخ متنی'}
            }
        }
    if persian_contains_any(t, ['تصویر', 'عکس', 'پوستر', 'طراحی کن', 'بساز', 'بکش']):
        if persian_contains_any(t, ['بساز', 'تولید', 'ایجاد', 'بکش', 'طراحی کن', 'بسازش']):
            ar = extract_aspect_ratio(t)
            eng = translate_to_english(t)
            return {'intent': 'generate_image', 'english_prompt': eng, 'aspect_ratio': ar}
    return None

def sse(data):
    return f"data: {json.dumps(data, ensure_ascii=False)}\n\n"

def build_model_contents(history_msgs, new_user):
    contents = []
    for m in history_msgs or []:
        if m.get('role') == 'user':
            contents += to_genai_parts(m.get('parts', []))
        elif m.get('role') == 'model':
            text_acc = ''
            for pr in m.get('parts', []):
                if 'text' in pr:
                    text_acc += pr['text']
            if text_acc:
                contents.append(text_acc)
    if new_user:
        contents += to_genai_parts(new_user.get('parts', []))
    return contents

@app.route('/chat', methods=['POST'])
def chat():
    data = request.get_json(force=True) or {}
    chat_id = data.get('chatId') or str(int(time.time() * 1000))
    model_name = data.get('model') or 'gemini-1.5-pro-latest'
    new_user = data.get('newUserMessage')
    history_override = data.get('history')
    action = data.get('action')

    if new_user:
        append_chat(chat_id, {'ts': int(time.time() * 1000), 'role': 'user', 'parts': new_user.get('parts', [])})

    user_text = ''
    user_parts = []
    if new_user:
        user_parts = new_user.get('parts', [])
        for p in user_parts:
            if 'text' in p:
                user_text += p['text'] + '\n'

    if action and action.get('intent') == 'regenerate_with_enhancement':
        user_text += '\n' + (action.get('enhancement') or '')

    intent_payload = detect_intent(user_text, user_parts)

    def stream():
        try:
            if intent_payload:
                yield sse(intent_payload)
                return
            msgs = history_override if history_override else read_chat(chat_id)
            contents = build_model_contents(msgs, new_user)
            model = get_model(model_name)
            resp = model.generate_content(contents, stream=True)
            full_text = ''
            for chunk in resp:
                t = getattr(chunk, 'text', None)
                if t:
                    full_text += t
                    yield sse({'candidates': [{'content': {'parts': [{'text': t}]}}]})
            if full_text:
                append_chat(chat_id, {'ts': int(time.time() * 1000), 'role': 'model', 'parts': [{'text': full_text}]})
        except Exception as e:
            try:
                yield sse({'error': {'message': str(e)}})
            except Exception:
                pass
    return Response(stream(), mimetype='text/event-stream')

@app.route('/history/<chat_id>')
def history_route(chat_id):
    return jsonify(read_chat(chat_id))

@app.route('/healthz')
def healthz():
    return jsonify({'ok': True})

@app.route('/')
def index():
    return render_template('index.html')

(Dockerfile (5).txt)
(requirements (1) (8).txt)
(main (15).js)
(api (20).js)
(api (20).js)

javascript
const SESSIONS_KEY = 'alphaChatSessions';
const ACTIVE_KEY = 'alphaActiveChatId';
export const MAX_CHAT_SESSIONS = 150;

export let chatSessions = [];
export let activeChatId = null;
export let attachedFile = null;
export let isGenerating = false;
export let globalAbortController = null;
export let currentImageEventSource = null;
export let currentUploadXHR = null;
export let isGpuGuideActive = false;

function enforceSessionLimit() {
  if (Array.isArray(chatSessions) && chatSessions.length > MAX_CHAT_SESSIONS) {
    chatSessions.splice(MAX_CHAT_SESSIONS);
  }
}

export function saveSessions() {
  enforceSessionLimit();
  try {
    const sessionsToSave = JSON.parse(JSON.stringify(chatSessions || []));
    sessionsToSave.forEach(s => {
      (s.messages || []).forEach(m => {
        (m.parts || []).forEach(p => { if ('base64Data' in p) delete p.base64Data; });
      });
    });
    localStorage.setItem(SESSIONS_KEY, JSON.stringify(sessionsToSave));
    if (activeChatId) localStorage.setItem(ACTIVE_KEY, activeChatId);
  } catch (_) {}
}

export function loadSessions() {
  try {
    const raw = localStorage.getItem(SESSIONS_KEY);
    chatSessions = raw ? JSON.parse(raw) : [];
  } catch (_) {
    chatSessions = [];
  }
  try {
    activeChatId = localStorage.getItem(ACTIVE_KEY) || (chatSessions[0]?.id ?? null);
  } catch (_) {
    activeChatId = chatSessions[0]?.id ?? null;
  }
  enforceSessionLimit();
}

export function setChatSessions(newSessions) {
  chatSessions = Array.isArray(newSessions) ? newSessions : [];
}

export function setActiveChatId(id) {
  activeChatId = id || null;
  if (id) localStorage.setItem(ACTIVE_KEY, id); else localStorage.removeItem(ACTIVE_KEY);
}

export function getActiveChat() {
  return chatSessions.find(s => s.id === activeChatId) || null;
}

export function deleteChat(id) {
  const idx = chatSessions.findIndex(s => s.id === id);
  if (idx !== -1) chatSessions.splice(idx, 1);
  if (activeChatId === id) activeChatId = chatSessions[0]?.id ?? null;
  saveSessions();
}

export function setAttachedFile(file) { attachedFile = file || null; }
export function setGpuGuideState(v) { isGpuGuideActive = !!v; }
export function setCurrentUploadXHR(xhr) { currentUploadXHR = xhr || null; }
export function setCurrentImageEventSource(es) { currentImageEventSource = es || null; }
export function setGlobalAbortController(controller) { globalAbortController = controller || null; }

export function setGeneratingState(v) {
  isGenerating = !!v;
  if (isGenerating) {
    globalAbortController = new AbortController();
  } else {
    globalAbortController = null;
  }
  return globalAbortController;
}

export function clearTransientState() {
  attachedFile = null;
  currentUploadXHR = null;
  currentImageEventSource = null;
}

export function findLastIndex(arr, predicate) {
  if (!Array.isArray(arr)) return -1;
  for (let i = arr.length - 1; i >= 0; i--) {
    if (predicate(arr[i])) return i;
  }
  return -1;
}

export function deleteMessage(chatId, messageIndex) {
  const chat = chatSessions.find(s => s.id === chatId);
  if (!chat || !Array.isArray(chat.messages)) return;
  if (messageIndex >= 0 && messageIndex < chat.messages.length) {
    chat.messages.splice(messageIndex, 1);
    saveSessions();
  }
}

حق با توئه—مشکل از اینه که توی main.js داری ui.setGeneratingState(...) صدا می‌زنی، در حالی‌که همچین تابعی توی ui.js وجود نداره و همین باعث خطای جاوااسکریپت و بی‌عمل‌بودن دکمه ارسال می‌شه. این فراخوان باید از state انجام بشه نه ui (یعنی state.setGeneratingState(...)). اینجا در خود کدت دیده می‌شه که ui.setGeneratingState(true) صدا زده شده و چنین تابعی در ui.js تعریف نشده. (main (15).js) (ui (10).js)
همچنین نسخه‌ی فعلی state.jsای که داری فقط setGenerating داره و کنترلر قطع‌جریان (AbortController) رو نمی‌سازه؛ در حالی‌که بقیه‌ی کدت انتظار یه تابع «حالت‌گذار» کامل داره. (state (4).js)

نسخه‌ی درست state.js (بدون هیچ توضیح داخل کد)

javascript
const SESSIONS_KEY = 'alphaChatSessions';
const ACTIVE_KEY = 'alphaActiveChatId';
export const MAX_CHAT_SESSIONS = 150;

export let chatSessions = [];
export let activeChatId = null;
export let attachedFile = null;
export let isGenerating = false;
export let globalAbortController = null;
export let currentImageEventSource = null;
export let currentUploadXHR = null;
export let isGpuGuideActive = false;

function enforceSessionLimit() {
  if (Array.isArray(chatSessions) && chatSessions.length > MAX_CHAT_SESSIONS) {
    chatSessions.splice(MAX_CHAT_SESSIONS);
  }
}

export function loadSessions() {
  try {
    const raw = localStorage.getItem(SESSIONS_KEY);
    chatSessions = raw ? JSON.parse(raw) : [];
  } catch (_) {
    chatSessions = [];
  }
  try {
    activeChatId = localStorage.getItem(ACTIVE_KEY) || (chatSessions[0]?.id ?? null);
  } catch (_) {
    activeChatId = chatSessions[0]?.id ?? null;
  }
  enforceSessionLimit();
}

export function saveSessions() {
  enforceSessionLimit();
  try {
    const sessionsToSave = JSON.parse(JSON.stringify(chatSessions || []));
    sessionsToSave.forEach(s => {
      (s.messages || []).forEach(m => {
        (m.parts || []).forEach(p => { if ('base64Data' in p) delete p.base64Data; });
      });
    });
    localStorage.setItem(SESSIONS_KEY, JSON.stringify(sessionsToSave));
    if (activeChatId) localStorage.setItem(ACTIVE_KEY, activeChatId);
  } catch (_) {}
}

export function setChatSessions(newSessions) { chatSessions = Array.isArray(newSessions) ? newSessions : []; }
export function setActiveChatId(id) { activeChatId = id || null; if (id) localStorage.setItem(ACTIVE_KEY, id); else localStorage.removeItem(ACTIVE_KEY); }
export function getActiveChat() { return chatSessions.find(s => s.id === activeChatId) || null; }
export function deleteChat(id) { const i = chatSessions.findIndex(s => s.id === id); if (i !== -1) chatSessions.splice(i,1); if (activeChatId === id) activeChatId = chatSessions[0]?.id ?? null; saveSessions(); }

export function setAttachedFile(file) { attachedFile = file || null; }
export function setGpuGuideState(v) { isGpuGuideActive = !!v; }
export function setCurrentUploadXHR(xhr) { currentUploadXHR = xhr || null; }
export function setCurrentImageEventSource(es) { currentImageEventSource = es || null; }

export function setGeneratingState(v) {
  isGenerating = !!v;
  globalAbortController = v ? new AbortController() : null;
  return globalAbortController;
}

export function clearTransientState() {
  attachedFile = null;
  currentUploadXHR = null;
  currentImageEventSource = null;
}

export function findLastIndex(arr, predicate) {
  if (!Array.isArray(arr)) return -1;
  for (let i = arr.length - 1; i >= 0; i--) if (predicate(arr[i])) return i;
  return -1;
}

export function deleteMessage(chatId, messageIndex) {
  const chat = chatSessions.find(s => s.id === chatId);
  if (!chat || !Array.isArray(chat.messages)) return;
  if (messageIndex >= 0 && messageIndex < chat.messages.length) {
    chat.messages.splice(messageIndex, 1);
    saveSessions();
  }
}

export function updateLastUserMessageWithImageGenData(chatId, englishPrompt, aspectRatio) {
  const chat = chatSessions.find(s => s.id === chatId);
  if (!chat) return;
  for (let i = chat.messages.length - 1; i >= 0; i--) {
    const msg = chat.messages[i];
    if (msg.role === 'user') {
      msg.image_generation_payload = { english_prompt: englishPrompt, aspect_ratio: aspectRatio };
      break;
    }
  }
  saveSessions();
}

یک تغییر خیلی کوچک در main.js

در هر جایی که این رو داری:

diff
- ui.setGeneratingState(true)
+ state.setGeneratingState(true)

این همون چیزی‌ه که باعث می‌شه سابمیت درست کار کنه. جایی که الان اشتباه صدا زده شده همین هندلر سابمیت فرم هست. (main (15).js)

اگر باز هم گیر کردی، اسم فایل‌ها و نسخه‌هایی که الان روی Space دپلوی شده رو بگو تا همون‌جا برات ست-به-ست اصلاحش کنم.

main.js

javascript
import * as state from './state.js';
import * as ui from './ui.js';
import * as api from './api.js';

// Polyfills for older state.js versions
if (typeof state.setGenerating !== 'function') {
  state.setGenerating = (v) => { state.isGenerating = !!v; };
}
const deleteMessageAndFollowingFallback = (chatId, messageIndex) => {
  const chat = state.chatSessions.find(s => s.id === chatId);
  if (!chat || !Array.isArray(chat.messages)) return;
  chat.messages.splice(messageIndex);
  if (typeof state.saveSessions === 'function') state.saveSessions();
};

// File selection / upload
async function handleFileSelection(event) {
  const file = event.target.files[0];
  if (!file) return;

  ui.showFileUploading(file.name);
  ui.dom.submitButton.disabled = true;

  try {
    const onProgress = (percent) => { ui.updateUploadProgress(percent); };
    const uploadedFileData = await api.processAndUploadFile(file, onProgress);
    state.setAttachedFile(uploadedFileData);
    ui.showFileReady(file.name, file.type, uploadedFileData.url);
  } catch (error) {
    console.error("خطا در آپلود فایل:", error);
    if (error.message !== 'آپلود توسط کاربر لغو شد.') {
      ui.showFileError(error.message);
    } else {
      ui.hideFilePreview();
    }
  } finally {
    event.target.value = '';
    ui.toggleFilePopupMenu(false);
    ui.dom.submitButton.disabled = false;
  }
}

// Load active chat (from dataset via backend) and render
async function loadAndRenderActiveChat() {
  const activeChat = state.getActiveChat();
  if (!activeChat) {
    handleNewChat();
    return;
  }
  try {
    if (activeChat.messages.length === 0 && !activeChat.isNew) {
      const response = await fetch(`/history/${activeChat.id}`);
      if (response.ok) {
        activeChat.messages = await response.json();
      } else {
        console.error("Failed to load chat history from server.");
      }
    }
  } catch (error) {
    console.error("Error fetching chat history:", error);
  } finally {
    ui.renderActiveChat();
    ui.renderHistoryList();
  }
}

// New chat
function handleNewChat() {
  const newSession = { id: Date.now().toString(), title: 'چت جدید', model: 'gemini-1.5-pro-latest', messages: [], isNew: true };
  state.chatSessions.unshift(newSession);
  state.setActiveChatId(newSession.id);
  state.saveSessions && state.saveSessions();
  ui.renderActiveChat();
  ui.renderHistoryList();
}

// Export helpers
function getFullChatText(session) {
  if (!session || !session.messages) return "";
  return session.messages
    .map(msg => {
      const prefix = msg.role === 'user' ? 'کاربر' : 'مدل';
      const textContent = msg.parts?.find(p => p.text)?.text || '[محتوای غیر متنی]';
      return `${prefix}:\n${textContent}`;
    })
    .join('\n\n---\n\n');
}

document.addEventListener('DOMContentLoaded', () => {
  ui.initTheme();
  state.loadSessions();

  if (state.chatSessions.length === 0 || !state.getActiveChat()) {
    handleNewChat();
  } else {
    state.setActiveChatId(state.activeChatId || state.chatSessions[0].id);
    loadAndRenderActiveChat();
  }

  ui.setupMobileKeyboardFix();
  ui.setMinTextareaHeight(ui.dom.messageInput.scrollHeight);
  ui.dom.messageForm.style.borderRadius = '28px';

  // Sidebar / header
  ui.dom.newChatButton.addEventListener('click', handleNewChat);
  ui.dom.menuButton.addEventListener('click', () => ui.toggleSidebar(true));
  ui.dom.sidebarOverlay.addEventListener('click', () => ui.toggleSidebar(false));

  // Delete all chats
  ui.dom.deleteAllChatsButton.addEventListener('click', () => {
    ui.showConfirmModal('آیا از حذف تمام چت‌ها مطمئن هستید؟ این عمل غیرقابل بازگشت است.', () => {
      state.setChatSessions([]);
      state.setActiveChatId(null);
      state.saveSessions && state.saveSessions();
      handleNewChat();
      ui.toggleSidebar(false);
    });
  });

  // Model picker
  ui.dom.modelSelectButton.addEventListener('click', () => ui.toggleModal(true));
  ui.dom.modelSelectModal.addEventListener('click', (e) => {
    if (e.target === ui.dom.modelSelectModal) ui.toggleModal(false);
  });
  ui.dom.modelOptionCards.forEach(card => {
    card.addEventListener('click', () => {
      const activeChat = state.getActiveChat();
      if (!activeChat) return;
      activeChat.model = card.dataset.model;
      ui.dom.currentModelName.textContent = card.dataset.name;
      ui.updateRadioButtons();
      state.saveSessions && state.saveSessions();
      ui.toggleModal(false);
    });
  });

  // Settings / theme
  ui.dom.settingsButton.addEventListener('click', () => ui.toggleSettingsModal(true));
  ui.dom.settingsModal.addEventListener('click', (e) => {
    if (e.target === ui.dom.settingsModal) ui.toggleSettingsModal(false);
  });
  ui.dom.themeToggle.addEventListener('change', (e) => {
    const newTheme = e.target.checked ? 'dark' : 'light';
    localStorage.setItem('theme', newTheme);
    ui.applyTheme(newTheme);
  });

  // File popup
  ui.dom.attachFileButton.addEventListener('click', (e) => {
    e.stopPropagation();
    const isVisible = !ui.dom.filePopupMenu.classList.contains('hidden');
    ui.toggleFilePopupMenu(!isVisible);
  });
  window.addEventListener('click', (e) => {
    if (!ui.dom.filePopupMenu.classList.contains('hidden') &&
        !ui.dom.filePopupMenu.contains(e.target) &&
        e.target !== ui.dom.attachFileButton &&
        !ui.dom.attachFileButton.contains(e.target)) {
      ui.toggleFilePopupMenu(false);
    }
  });
  ui.dom.selectImageOption.addEventListener('click', () => { ui.dom.imageFileInput.click(); });
  ui.dom.selectFileOption.addEventListener('click', () => { ui.dom.generalFileInput.click(); });
  ui.dom.imageFileInput.addEventListener('change', handleFileSelection);
  ui.dom.generalFileInput.addEventListener('change', handleFileSelection);

  // Remove file
  ui.dom.removeImageButton.addEventListener('click', () => {
    if (state.currentUploadXHR) {
      state.currentUploadXHR.abort();
      console.log("آپلود توسط کاربر لغو شد.");
    }
    state.setAttachedFile(null);
    ui.hideFilePreview();
    ui.dom.submitButton.disabled = false;
  });

  // HTML preview modal
  ui.dom.htmlPreviewCloseBtn.addEventListener('click', () => ui.toggleHtmlPreviewModal(false));
  ui.dom.htmlPreviewOverlay.addEventListener('click', () => ui.toggleHtmlPreviewModal(false));

  // Gallery download
  ui.dom.galleryDownloadBtn.addEventListener('click', function() {
    const url = ui.getCurrentGalleryImageUrl();
    if (url) api.uploadToAISADAAndOpenAlpha(url, this);
  });

  // Submit / stop
  ui.dom.messageForm.addEventListener('submit', async (e) => {
    e.preventDefault();
    if (state.isGenerating) {
      if (state.globalAbortController) state.globalAbortController.abort();
      if (state.currentImageEventSource) state.currentImageEventSource.close();
      return;
    }

    const activeChat = state.getActiveChat();
    if (!activeChat) return;

    const userMessageText = ui.dom.messageInput.value.trim();
    if (!userMessageText && !state.attachedFile) return;

    ui.setGeneratingState(true);

    const isFirstMessageOfChat = activeChat.messages.length === 0;
    if (isFirstMessageOfChat) {
      const welcomeScreen = ui.dom.chatWindow.querySelector('.welcome-screen');
      if (welcomeScreen) welcomeScreen.remove();
    }

    const previousLastUserIndex = state.findLastIndex(activeChat.messages, msg => msg.role === 'user');
    if (previousLastUserIndex !== -1) {
      const previousUserElement = ui.dom.chatWindow.querySelector(`.message-entry[data-index="${previousLastUserIndex}"]`);
      if (previousUserElement) {
        ui.updateMessageActions(previousUserElement, activeChat.messages[previousLastUserIndex], false, false);
      }
    }

    const previousLastModelIndex = state.findLastIndex(activeChat.messages, msg => msg.role === 'model');
    if (previousLastModelIndex !== -1) {
      const isItTheLastMessageOverall = previousLastModelIndex === activeChat.messages.length - 1;
      if (isItTheLastMessageOverall) {
        const previousModelElement = ui.dom.chatWindow.querySelector(`.message-entry[data-index="${previousLastModelIndex}"]`);
        if (previousModelElement) {
          ui.updateMessageActions(previousModelElement, activeChat.messages[previousLastModelIndex], false, false);
        }
      }
    }

    const userParts = [];
    if (state.attachedFile) {
      userParts.push({
        fileUrl: state.attachedFile.url,
        mimeType: state.attachedFile.mimeType,
        name: state.attachedFile.name,
        base64Data: state.attachedFile.base64Data
      });
      ui.hideFilePreview();
    }
    if (userMessageText) userParts.push({ text: userMessageText });

    const newUserMessage = { role: 'user', parts: userParts };
    activeChat.messages.push(newUserMessage);
    ui.addMessageToUI(newUserMessage, activeChat.messages.length - 1, { isLastUser: true, animate: true });

    const modelPlaceholderMessage = { role: 'model', isTemporary: true, parts: [] };
    activeChat.messages.push(modelPlaceholderMessage);
    const modelBubbleOuterDiv = ui.addMessageToUI(modelPlaceholderMessage, activeChat.messages.length - 1, { animate: true });

    if (isFirstMessageOfChat) {
      if (userMessageText) {
        activeChat.title = userMessageText.substring(0, 30) + (userMessageText.length > 30 ? '...' : '');
      } else if (state.attachedFile) {
        activeChat.title = `فایل: ${state.attachedFile.name}`;
      }
      delete activeChat.isNew;
      state.saveSessions && state.saveSessions();
      ui.renderHistoryList();
    }

    ui.dom.messageInput.value = '';
    ui.dom.messageInput.dispatchEvent(new Event('input'));

    try {
      await api.streamResponse(modelBubbleOuterDiv, activeChat, newUserMessage);
    } finally {
      if (state.attachedFile) state.setAttachedFile(null);
    }
  });

  // Chat window actions
  ui.dom.chatWindow.addEventListener('click', async (e) => {
    const galleryItem = e.target.closest('.js-image-gallery-grid [data-index]');
    if (galleryItem) {
      const grid = galleryItem.closest('.js-image-gallery-grid');
      const urls = grid.dataset.urls;
      const index = galleryItem.dataset.index;
      if (urls && index !== undefined) {
        ui.openImageGallery(urls, parseInt(index, 10));
        return;
      }
    }

    const clarificationButton = e.target.closest('.clarification-button');
    if (clarificationButton) {
      const payloadString = clarificationButton.dataset.actionPayload;
      if (!payloadString || state.isGenerating) return;

      const actionPayload = JSON.parse(payloadString);
      const activeChat = state.getActiveChat();
      if (!activeChat) return;

      ui.setGeneratingState(true);

      const clarificationMessageElement = clarificationButton.closest('.message-entry');
      const clarificationMessageIndex = parseInt(clarificationMessageElement.dataset.index, 10);
      if (isNaN(clarificationMessageIndex)) {
        ui.resetState();
        return;
      }

      const modelPlaceholderMessage = { role: 'model', isTemporary: true, parts: [] };
      activeChat.messages[clarificationMessageIndex] = modelPlaceholderMessage;
      const newModelBubble = ui.addMessageToUI(modelPlaceholderMessage, clarificationMessageIndex, {}, clarificationMessageElement);

      const historyBeforeAction = activeChat.messages.slice(0, clarificationMessageIndex);

      if (actionPayload.intent === 'edit_image') {
        let fileUrlForEditing = null;
        for (let i = historyBeforeAction.length - 1; i >= 0; i--) {
          const msg = historyBeforeAction[i];
          if (msg.parts) {
            const imagePart = msg.parts.find(p => p.image_url || (p.edited_images && p.edited_images.length > 0));
            if (imagePart) { fileUrlForEditing = imagePart.image_url || imagePart.edited_images[0]; break; }
            const filePart = msg.parts.find(p => p.fileUrl);
            if (filePart) { fileUrlForEditing = filePart.fileUrl; break; }
          }
        }
        if (fileUrlForEditing) {
          await api.runExternalImageEditor(actionPayload.prompt, fileUrlForEditing, newModelBubble, clarificationMessageIndex);
        } else {
          ui.displayError(newModelBubble, "متاسفانه تصویری برای ویرایش پیدا نشد.");
          ui.resetState();
        }
      } else if (actionPayload.intent === 'regenerate_with_enhancement') {
        await api.streamResponse(newModelBubble, activeChat, null, historyBeforeAction, actionPayload);
      }
      return;
    }

    const button = e.target.closest('.action-button');
    if (!button) return;

    const action = button.dataset.action;
    const messageEntry = button.closest('.message-entry');
    if (!messageEntry) return;

    const messageIndex = parseInt(messageEntry.dataset.index, 10);
    const activeChat = state.getActiveChat();
    if (!activeChat || isNaN(messageIndex)) return;

    const message = activeChat.messages[messageIndex];

    if (action === 'download-image') {
      const imageUrl = message.parts.find(p => p.image_url)?.image_url;
      if (imageUrl) api.uploadToAISADAAndOpenAlpha(imageUrl, button);
    } else if (action === 'copy') {
      const textToCopy = message.parts?.find(p => p.text)?.text || '';
      if (textToCopy) {
        navigator.clipboard.writeText(textToCopy).then(() => ui.showCopyFeedback(button));
      }
    } else if (action === 'like' || action === 'dislike') {
      ui.handleLikeDislike(button, messageEntry);
    } else if (action === 'regenerate') {
      if (state.isGenerating) return;

      ui.setGeneratingState(true);
      state.setGpuGuideState && state.setGpuGuideState(false);

      const lastModelMessageIndex = state.findLastIndex(activeChat.messages, msg => msg.role === 'model');

      if (messageIndex === lastModelMessageIndex) {
        activeChat.messages.length = messageIndex;
        messageEntry.remove();

        const lastUserMessageIndex = state.findLastIndex(activeChat.messages, msg => msg.role === 'user');
        if (lastUserMessageIndex !== -1) {
          const lastUserMessageElement = ui.dom.chatWindow.querySelector(`.message-entry[data-index="${lastUserMessageIndex}"]`);
          if (lastUserMessageElement) {
            ui.updateMessageActions(lastUserMessageElement, activeChat.messages[lastUserMessageIndex], true, false);
          }
        }

        const modelPlaceholderMessage = { role: 'model', isTemporary: true, parts: [] };
        activeChat.messages.push(modelPlaceholderMessage);
        const newModelBubble = ui.addMessageToUI(modelPlaceholderMessage, activeChat.messages.length - 1, { animate: true });
        await api.streamResponse(newModelBubble, activeChat, null, activeChat.messages.slice(0, -1));
      } else {
        ui.resetState();
      }
    } else if (action === 'edit') {
      if (state.isGenerating) return;

      const lastUserMessageIndex = state.findLastIndex(activeChat.messages, msg => msg.role === 'user');
      if (messageIndex === lastUserMessageIndex) {
        const textPart = message.parts.find(p => p.text);
        const filePart = message.parts.find(p => p.fileUrl);

        if (textPart || filePart) {
          ui.showEditModal(textPart ? textPart.text : '', async (newText) => {
            ui.setGeneratingState(true);

            const allMessagesInDOM = ui.dom.chatWindow.querySelectorAll('.message-entry');
            allMessagesInDOM.forEach(msgEl => {
              const idx = parseInt(msgEl.dataset.index, 10);
              if (idx >= messageIndex) msgEl.remove();
            });

            const historyUpToEdit = activeChat.messages.slice(0, messageIndex);
            activeChat.messages.length = messageIndex;

            const newParts = [];
            if (filePart) newParts.push(filePart);
            if (newText.trim()) newParts.push({ text: newText });

            const editedUserMessage = { role: 'user', parts: newParts };
            const historyForApi = [...historyUpToEdit, editedUserMessage];

            activeChat.messages.push(editedUserMessage);
            ui.addMessageToUI(editedUserMessage, activeChat.messages.length - 1, { isLastUser: true, animate: true });

            const modelPlaceholderMessage = { role: 'model', isTemporary: true, parts: [] };
            activeChat.messages.push(modelPlaceholderMessage);
            state.saveSessions && state.saveSessions();

            const newModelBubble = ui.addMessageToUI(modelPlaceholderMessage, activeChat.messages.length - 1, { animate: true });
            await api.streamResponse(newModelBubble, activeChat, null, historyForApi);
          });
        }
      }
    } else if (action === 'show-message-menu') {
      ui.showMessageMenu(e, messageIndex);
    }
  });

  // History item menu (rename/delete/export)
  ui.dom.historyItemMenu.addEventListener('click', (e) => {
    const button = e.target.closest('.menu-item');
    if (!button) return;

    const action = button.dataset.action;
    const format = button.dataset.format;
    const sessionId = ui.dom.historyItemMenu.dataset.sessionId;
    const session = state.chatSessions.find(s => s.id === sessionId);
    if (!session) return;

    if (action === 'rename') {
      ui.showRenameModal(session.title, (newTitle) => {
        session.title = newTitle;
        state.saveSessions && state.saveSessions();
        ui.renderHistoryList();
      });
    } else if (action === 'delete') {
      ui.showConfirmModal(`آیا از حذف گفتگوی "${session.title}" مطمئن هستید؟`, () => {
        state.deleteChat(sessionId);
        if (state.activeChatId === sessionId) {
          state.setActiveChatId(null);
          loadAndRenderActiveChat();
        } else {
          ui.renderHistoryList();
        }
      });
    } else if (action === 'convert-chat') {
      const fullText = getFullChatText(session);
      api.convertTextToFile(fullText, format, button);
    }
    ui.dom.historyItemMenu.classList.remove('visible');
  });

  // Message item menu (delete/convert)
  ui.dom.messageItemMenu.addEventListener('click', (e) => {
    const menu = ui.dom.messageItemMenu;
    const closeMenu = () => {
      menu.classList.remove('visible');
      setTimeout(() => { menu.classList.add('hidden'); }, 300);
    };

    if (e.target === ui.dom.messageItemMenuOverlay) {
      closeMenu();
      return;
    }

    const button = e.target.closest('.menu-item');
    if (!button) return;

    const action = button.dataset.action;
    const format = button.dataset.format;
    const messageIndex = parseInt(menu.dataset.messageIndex, 10);
    const activeChat = state.getActiveChat();
    if (!activeChat || isNaN(messageIndex)) { closeMenu(); return; }
    const message = activeChat.messages[messageIndex];

    if (action === 'delete-message') {
      ui.showConfirmModal('آیا از حذف این پیام و تمام پیام‌های بعد از آن مطمئن هستید؟', () => {
        if (typeof state.deleteMessageAndFollowing === 'function') {
          state.deleteMessageAndFollowing(activeChat.id, messageIndex);
        } else {
          deleteMessageAndFollowingFallback(activeChat.id, messageIndex);
        }
        ui.renderActiveChat();
      });
    } else if (action === 'convert-message') {
      const textContent = message.parts?.find(p => p.text)?.text || '';
      if (textContent) {
        api.convertTextToFile(textContent, format, button);
      } else {
        alert('محتوای متنی برای تبدیل وجود ندارد.');
      }
    }
    closeMenu();
  });

  // Inputs autosize
  ui.dom.messageInput.addEventListener('input', () => {
    ui.adjustTextareaHeight(ui.dom.messageInput, ui.dom.messageForm);
  });
  ui.dom.editInput.addEventListener('input', () => {
    ui.adjustTextareaHeight(ui.dom.editInput);
  });
});

// Expose some helpers globally for inline handlers
window.handleSuggestionClick = ui.handleSuggestionClick;
window.uploadToAISADAAndOpenAlpha = api.uploadToAISADAAndOpenAlpha;