Final verified deployment for HF Space

.gitattributes

@@ -0,0 +1,11 @@
+# Handle line endings automatically
+* text=auto
+
+# Declare files that will always have LF line endings on checkout.
+*.sh text eol=lf
+*.py text eol=lf
+*.go text eol=lf
+*.tsx text eol=lf
+*.css text eol=lf
+*.html text eol=lf
+*.json text eol=lf

Dockerfile

@@ -0,0 +1,76 @@
+# ==========================================
+# Stage 1: Build Frontend (React/TS/Vite)
+# ==========================================
+FROM node:20-slim AS frontend-builder
+WORKDIR /app/frontend
+
+# Copy frontend definitions
+COPY frontend/package.json frontend/package-lock.json* ./
+RUN npm install
+
+# Copy source and build
+COPY frontend/ ./
+RUN npm run build
+
+# ==========================================
+# Stage 2: Build Backend (Golang)
+# ==========================================
+FROM golang:1.23 AS backend-builder
+WORKDIR /app/backend
+
+# Copy Go source
+COPY main.go .
+
+# Build static binary
+RUN go mod init vchat-server && \
+    go mod tidy && \
+    CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o vchat-server main.go
+
+# ==========================================
+# Stage 3: Final Runtime (PyTorch Base)
+# ==========================================
+FROM pytorch/pytorch:2.9.1-cuda13.0-cudnn9-devel
+
+ENV PYTHONUNBUFFERED=1 \
+    DEBIAN_FRONTEND=noninteractive \
+    LITE_MODE=false \
+    PATH="/usr/lib/google-cloud-sdk/bin:$PATH" \
+    PIP_NO_CACHE_DIR=1
+
+WORKDIR /app
+
+# 1. Install System Dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ffmpeg \
+    git \
+    curl \
+    gnupg \
+    ca-certificates \
+    && echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] https://packages.cloud.google.com/apt cloud-sdk main" | tee -a /etc/apt/sources.list.d/google-cloud-sdk.list \
+    && curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key --keyring /usr/share/keyrings/cloud.google.gpg add - \
+    && apt-get update && apt-get install -y google-cloud-cli \
+    && rm -rf /var/lib/apt/lists/*
+
+# 2. Install Python Dependencies
+RUN pip install uv
+COPY requirements.txt ./
+RUN uv pip install --system -r requirements.txt
+
+# 3. Copy Python Application Code
+COPY . .
+
+# 4. Install Built Artifacts
+COPY --from=backend-builder /app/backend/vchat-server /usr/local/bin/vchat-server
+RUN mkdir -p /usr/share/vchat/static
+COPY --from=frontend-builder /app/frontend/dist /usr/share/vchat/static
+
+# 5. Setup Entrypoint (Fix Windows Line Endings Here)
+COPY start.sh /usr/local/bin/start.sh
+RUN sed -i 's/\r$//' /usr/local/bin/start.sh && \
+    chmod +x /usr/local/bin/start.sh
+
+# Expose the Go Server port
+EXPOSE 8000
+
+# Run the Orchestrator
+CMD ["/usr/local/bin/start.sh"]

README.md

@@ -0,0 +1,73 @@
+---
+title: VFacts
+emoji: 😀
+colorFrom: gray
+colorTo: gray
+sdk: docker
+pinned: false
+---
+
+# VFacts - Video Veracity & Analysis Platform
+
+## Research Overview
+
+The liarMP4 project investigates the efficacy of Generative AI (GenAI) systems in detecting "contextual malformation" in video content, as opposed to traditional Predictive AI (PredAI) which focuses on metadata and engagement velocity.
+
+While traditional content moderation relies on scalar probabilities derived from tabular data (account age, keyword triggers), this research proposes a **Fractal Chain-of-Thought** methodology. This approach utilizes Multimodal Large Language Models to analyze the semantic dissonance between visual evidence, audio waveforms, and textual claims.
+
+The system generates **Veracity Vectors**, multi-dimensional scores representing Visual Integrity, Audio Integrity, and Cross-Modal Alignment—outputting data in a strict Token-Oriented Object Notation (TOON) schema.
+
+## Key Features
+
+*   **Predictive Benchmarking:** Comparison against AutoGluon/Gradient Boosting models trained on engagement metadata.
+*   **Fractal Chain-of-Thought (FCoT):** A recursive inference strategy that hypothesizes intent at a macro-scale and verifies pixel/audio artifacts at a meso-scale.
+*   **TOON Schema:** A standardized output format ensuring strict type adherence for database integration.
+*   **Human-in-the-Loop (HITL) Protocol:** A browser-based grounding workflow to calibrate AI "reasoning" against human authorial intent.
+
+## Project Resources
+
+*   **Live Demonstration (Hugging Face):** [https://huggingface.co/spaces/GlazedDon0t/liarMP4](https://huggingface.co/spaces/GlazedDon0t/liarMP4)
+*   **Source Code (GitHub):** [https://github.com/DevKlim/LiarMP4](https://github.com/DevKlim/LiarMP4)
+
+## Repository Structure
+
+*   **src/**: Core inference logic for the Generative AI pipeline and FCoT implementation.
+*   **preprocessing_tools/**: Scripts for training Predictive AI models on tabular datasets.
+*   **extension/**: Browser extension source code for the Human-in-the-Loop labeling workflow.
+*   **data/**: Benchmark datasets containing engagement metadata and manual veracity labels.
+
+## Installation and Usage
+
+This project is containerized to ensure reproducibility across different environments. The entire pipeline, including the inference logic and database connections, can be deployed using Docker.
+
+### Prerequisites
+
+*   Docker Engine
+*   Docker Compose
+
+### Deployment Instructions
+
+1.  Clone the repository:
+    ```bash
+    git clone https://github.com/DevKlim/LiarMP4.git
+    ```
+
+2.  Navigate to the project directory:
+    ```bash
+    cd LiarMP4/liarMP4
+    ```
+
+3.  Build and run the containerized environment:
+    ```bash
+    docker-compose up --build
+    ```
+
+The system will initialize the backend services and expose the necessary endpoints for the analysis pipeline.
+
+## License
+
+This research project is open-source. Please refer to the LICENSE file in the repository for specific terms regarding usage and distribution.
+
+## Authors
+
+Kliment Ho, Shiwei Yang, Keqing Li

frontend/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>vChat AI | Modern Inference</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

frontend/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "vchat-frontend",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "lucide-react": "^0.344.0",
+    "clsx": "^2.1.0",
+    "tailwind-merge": "^2.2.1"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.64",
+    "@types/react-dom": "^18.2.21",
+    "@vitejs/plugin-react": "^4.2.1",
+    "autoprefixer": "^10.4.18",
+    "postcss": "^8.4.35",
+    "tailwindcss": "^3.4.1",
+    "typescript": "^5.2.2",
+    "vite": "^5.1.4"
+  }
+}

frontend/postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

frontend/src/App.tsx

@@ -0,0 +1,766 @@
+import React, { useState, useRef, useEffect } from 'react';
+import { 
+  AlertCircle, Play, Upload, Layers, Terminal, Cpu, Activity, 
+  FileText, Zap, MessageSquare, Sliders, LayoutDashboard, FileJson, 
+  ChevronDown, ChevronRight, Bot, Database, Trash2, Eye, StopCircle, List,
+  CheckCircle, XCircle, BrainCircuit, Edit3, ClipboardList, CheckSquare,
+  BarChart2, TrendingUp, TrendingDown, Scale, ExternalLink
+} from 'lucide-react';
+
+function App() {
+  const [activeTab, setActiveTab] = useState('queue');
+  const [logs, setLogs] = useState<string>('System Ready.\n');
+  const [isProcessing, setIsProcessing] = useState(false);
+  
+  // Data States
+  const [dataList, setDataList] = useState<any[]>([]);
+  const [queueList, setQueueList] = useState<any[]>([]);
+  const [workflowList, setWorkflowList] = useState<any[]>([]);
+  const [comparisonList, setComparisonList] = useState<any[]>([]);
+  
+  const [expandedRow, setExpandedRow] = useState<string | null>(null);
+  const [refreshTrigger, setRefreshTrigger] = useState(0);
+
+  // Manual Labeling Modal
+  const [labelingItem, setLabelingItem] = useState<any>(null);
+  const [manualForm, setManualForm] = useState({
+      visual: 5, audio: 5, source: 5, logic: 5, emotion: 5,
+      va: 5, vc: 5, ac: 5,
+      final: 50,
+      reasoning: '',
+      tags: ''
+  });
+
+  const [videoUrl, setVideoUrl] = useState('');
+  const [model, setModel] = useState('vertex'); 
+  const [reasoningMethod, setReasoningMethod] = useState('cot');
+  const fileInputRef = useRef<HTMLInputElement>(null);
+  const logEndRef = useRef<HTMLDivElement>(null);
+  
+  useEffect(() => {
+    logEndRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [logs]);
+
+  // Refresh Data logic
+  useEffect(() => {
+    if (activeTab === 'moderation') {
+      fetch('/manage/list').then(res => res.json()).then(setDataList).catch(err => console.error("Data Load Error:", err));
+    }
+    if (activeTab === 'queue') {
+      fetch('/queue/list').then(res => res.json()).then(setQueueList).catch(err => console.error("Queue Load Error:", err));
+    }
+    if (activeTab === 'workflow') {
+      fetch('/workflow/status').then(res => res.json()).then(setWorkflowList).catch(err => console.error("Workflow Load Error:", err));
+    }
+    if (activeTab === 'analytics') {
+      fetch('/manage/comparison_data').then(res => res.json()).then(setComparisonList).catch(err => console.error("Analytics Load Error:", err));
+    }
+  }, [activeTab, refreshTrigger]);
+
+  const appendLog = (text: string) => setLogs(prev => prev + text);
+
+  // --- Handlers ---
+  
+  const handleFileUpload = async (e: React.ChangeEvent<HTMLInputElement>) => {
+    if (!e.target.files?.length) return;
+    const file = e.target.files[0];
+    const fd = new FormData();
+    fd.append("file", file);
+    
+    appendLog(`[SYSTEM] Uploading ${file.name} to queue...\n`);
+    try {
+      const res = await fetch('/queue/upload_csv', { method: 'POST', body: fd });
+      const data = await res.json();
+      if(data.error) throw new Error(data.error);
+      appendLog(`[SYSTEM] Upload complete. Added ${data.added} links.\n`);
+      setRefreshTrigger(prev => prev + 1);
+    } catch (err: any) {
+      appendLog(`[ERROR] Upload failed: ${err.message}\n`);
+    }
+  };
+
+  const handleStartQueue = async (e: React.FormEvent) => {
+    e.preventDefault();
+    setIsProcessing(true);
+    setLogs("[SYSTEM] Starting Queue Processing...\n");
+
+    const form = document.getElementById('control-form') as HTMLFormElement;
+    const formData = new FormData(form);
+
+    try {
+      const response = await fetch('/queue/run', { method: 'POST', body: formData });
+      if (!response.body) throw new Error("No response");
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = decoder.decode(value, { stream: true });
+        chunk.split('\n\n').forEach(line => {
+          if (line.startsWith('data:')) appendLog(line.replace('data:', '').trim() + '\n');
+          if (line.startsWith('event: close')) setIsProcessing(false);
+        });
+      }
+    } catch (err: any) {
+      appendLog(`\n[ERROR]: ${err.message}\n`);
+    } finally {
+      setIsProcessing(false);
+      setRefreshTrigger(prev => prev + 1);
+    }
+  };
+
+  const handleStopQueue = async () => {
+      await fetch('/queue/stop', { method: 'POST' });
+      appendLog("[USER] Stop signal sent. Finishing current item...\n");
+  };
+
+  const handleDelete = async (id: string, link: string) => {
+    if (!confirm("Delete this entry? This allows re-labeling of the link in the queue.")) return;
+    try {
+      const res = await fetch(`/manage/delete?id=${id}&link=${encodeURIComponent(link)}`, { method: 'DELETE' });
+      const json = await res.json();
+      if (json.status === 'deleted') {
+        setRefreshTrigger(prev => prev + 1);
+      } else {
+        alert("Error deleting: " + JSON.stringify(json));
+      }
+    } catch (e) { alert("Fail: " + e); }
+  };
+
+  const handleQueueDelete = async (link: string) => {
+    if(!confirm("Remove this link from queue?")) return;
+    try {
+        const res = await fetch(`/queue/delete?link=${encodeURIComponent(link)}`, { method: 'DELETE' });
+        const json = await res.json();
+        if(json.status === 'success') {
+            setRefreshTrigger(prev => prev + 1);
+        } else {
+            alert("Error: " + json.message);
+        }
+    } catch(err) {
+        console.error(err);
+    }
+  }
+
+  // --- Manual Labeling Handlers ---
+
+  const parseScore = (val: any) => {
+      if (!val) return 5;
+      const str = String(val).replace(/[^\d]/g, '');
+      const num = parseInt(str);
+      return isNaN(num) ? 5 : num;
+  };
+
+  const openLabelingModal = (item: any) => {
+      // Logic to handle source: workflow (item.ai_data) vs moderation (item direct)
+      let ai = item.ai_data || {};
+      
+      // Fallback: If coming from Moderation tab, item itself is the AI data
+      if (!item.ai_data && item.source_type === 'auto') {
+          ai = {
+              visual: item.visual_integrity_score,
+              final: item.final_veracity_score,
+              reasoning: item.final_reasoning,
+              tags: item.tags
+          };
+      }
+      
+      setLabelingItem(item);
+      setManualForm({
+          visual: parseScore(ai.visual),
+          audio: 5, source: 5, logic: 5, emotion: 5,
+          va: 5, vc: 5, ac: 5,
+          final: parseScore(ai.final || 50),
+          reasoning: ai.reasoning || '',
+          tags: ai.tags || ''
+      });
+  };
+
+  const submitManualLabel = async () => {
+      if(!labelingItem) return;
+      
+      const payload = {
+          link: labelingItem.link,
+          caption: "Manual Label via WebUI",
+          labels: {
+            visual_integrity_score: manualForm.visual,
+            audio_integrity_score: manualForm.audio,
+            source_credibility_score: manualForm.source,
+            logical_consistency_score: manualForm.logic,
+            emotional_manipulation_score: manualForm.emotion,
+            video_audio_score: manualForm.va,
+            video_caption_score: manualForm.vc,
+            audio_caption_score: manualForm.ac,
+            final_veracity_score: manualForm.final,
+            reasoning: manualForm.reasoning
+          },
+          tags: manualForm.tags,
+          stats: { platform: "webui" }
+      };
+
+      try {
+          const res = await fetch('/extension/save_manual', {
+              method: 'POST',
+              headers: {'Content-Type': 'application/json'},
+              body: JSON.stringify(payload)
+          });
+          const json = await res.json();
+          if(json.status === 'saved') {
+              alert("Manual Label Saved!");
+              setLabelingItem(null);
+              setRefreshTrigger(prev => prev + 1);
+          } else {
+              alert("Error: " + JSON.stringify(json));
+          }
+      } catch(e: any) {
+          alert("Error: " + e.message);
+      }
+  };
+
+  // Helper to segment workflow
+  const pendingVerification = workflowList.filter(row => row.ai_status === 'Labeled' && row.manual_status !== 'Completed');
+  const pendingAI = workflowList.filter(row => row.ai_status !== 'Labeled' && row.manual_status !== 'Completed');
+  const completed = workflowList.filter(row => row.manual_status === 'Completed');
+
+  // Helper for Analytics Summary
+  const calculateStats = () => {
+      if(comparisonList.length === 0) return { avgDelta: 0, bias: 0 };
+      let totalDelta = 0;
+      let totalAbsDelta = 0;
+      comparisonList.forEach(c => {
+          totalDelta += c.deltas.final; // Raw delta (+ means AI > Human)
+          totalAbsDelta += Math.abs(c.deltas.final);
+      });
+      return {
+          avgMAE: (totalAbsDelta / comparisonList.length).toFixed(1),
+          bias: (totalDelta / comparisonList.length).toFixed(1)
+      };
+  };
+  const stats = calculateStats();
+
+  return (
+    <div className="flex h-screen w-full bg-[#09090b] text-slate-200 font-sans overflow-hidden">
+      
+      {/* LEFT PANEL */}
+      <div className="w-[380px] flex flex-col border-r border-slate-800/60 bg-[#0c0c0e]">
+        <div className="h-16 flex items-center px-6 border-b border-slate-800/60">
+          <div className="flex items-center gap-3">
+            <div className="w-8 h-8 rounded-lg bg-indigo-600 flex items-center justify-center">
+              <Bot className="w-5 h-5 text-white" />
+            </div>
+            <h1 className="text-sm font-bold text-white">vChat <span className="text-slate-500">Manager</span></h1>
+          </div>
+        </div>
+
+        <div className="flex-1 overflow-y-auto p-6 space-y-6 custom-scrollbar">
+          <form id="control-form" className="space-y-6">
+            <div className="grid grid-cols-2 gap-1 p-1 bg-slate-900 rounded-lg border border-slate-800">
+               {[{id:'queue',l:'Ingest Queue',i:List}, {id:'workflow',l:'Labeling Workflow',i:ClipboardList}, {id:'moderation',l:'Dataset',i:Database}, {id:'analytics',l:'Showcase',i:BarChart2}].map(t => (
+                  <button key={t.id} type="button" onClick={() => setActiveTab(t.id)}
+                    className={`flex items-center justify-center gap-2 py-2 text-xs font-medium rounded ${activeTab===t.id ? 'bg-slate-800 text-white' : 'text-slate-500'}`}>
+                    <t.i className="w-3 h-3" /> {t.l}
+                  </button>
+               ))}
+            </div>
+
+            <div className="space-y-3">
+              <label className="text-xs font-bold text-slate-500 uppercase">Model Engine</label>
+              <select name="model_selection" value={model} onChange={(e) => setModel(e.target.value)}
+                className="w-full bg-slate-900 border border-slate-800 rounded px-3 py-2 text-xs outline-none focus:border-indigo-500">
+                <option value="vertex">Google Vertex AI</option>
+                <option value="gemini">Google Gemini API</option>
+              </select>
+
+              {model === 'gemini' && (
+                <div className="space-y-2">
+                  <input type="password" name="gemini_api_key" placeholder="Gemini API Key" className="w-full bg-black/20 border border-slate-800 rounded px-3 py-2 text-xs" />
+                  <input type="text" name="gemini_model_name" defaultValue="models/gemini-2.0-flash-exp" className="w-full bg-black/20 border border-slate-800 rounded px-3 py-2 text-xs" />
+                </div>
+              )}
+              {model === 'vertex' && (
+                 <div className="space-y-2">
+                   <input type="text" name="vertex_project_id" placeholder="GCP Project ID" className="w-full bg-black/20 border border-slate-800 rounded px-3 py-2 text-xs" />
+                   <div className="grid grid-cols-2 gap-2">
+                      <input type="text" name="vertex_location" defaultValue="us-central1" className="w-full bg-black/20 border border-slate-800 rounded px-3 py-2 text-xs" />
+                      <input type="text" name="vertex_model_name" defaultValue="gemini-1.5-pro-preview-0409" className="w-full bg-black/20 border border-slate-800 rounded px-3 py-2 text-xs" />
+                   </div>
+                 </div>
+              )}
+            </div>
+
+            <div className="space-y-3">
+                <label className="text-xs font-bold text-slate-500 uppercase flex items-center gap-2">
+                    <BrainCircuit className="w-3 h-3" /> Reasoning Architecture
+                </label>
+                <div className="grid grid-cols-2 gap-2">
+                    <button type="button" 
+                        onClick={() => setReasoningMethod('cot')}
+                        className={`py-2 px-3 rounded text-xs border ${reasoningMethod === 'cot' ? 'bg-indigo-900/40 border-indigo-500 text-indigo-300' : 'bg-slate-900 border-slate-800 text-slate-500 hover:border-slate-700'}`}>
+                        Standard CoT
+                    </button>
+                    <button type="button" 
+                        onClick={() => setReasoningMethod('fcot')}
+                        className={`py-2 px-3 rounded text-xs border ${reasoningMethod === 'fcot' ? 'bg-indigo-900/40 border-indigo-500 text-indigo-300' : 'bg-slate-900 border-slate-800 text-slate-500 hover:border-slate-700'}`}>
+                        Fractal CoT
+                    </button>
+                </div>
+                <input type="hidden" name="reasoning_method" value={reasoningMethod} />
+                <p className="text-[10px] text-slate-500">
+                    {reasoningMethod === 'cot' ? "Single-pass linear chain of thought." : "Recursive Multi-Scale (Macro → Meso → Consensus)."}
+                </p>
+            </div>
+
+            {activeTab === 'queue' && (
+               <div className="space-y-4">
+                 <div onClick={() => fileInputRef.current?.click()} className="border-2 border-dashed border-slate-700 hover:border-indigo-500 hover:bg-indigo-500/5 rounded-xl p-4 text-center cursor-pointer transition-colors">
+                     <Upload className="w-5 h-5 mx-auto text-slate-500 mb-1" />
+                     <p className="text-xs text-slate-400">Upload CSV to Queue</p>
+                     <input type="file" ref={fileInputRef} onChange={handleFileUpload} accept=".csv" hidden />
+                 </div>
+                 <div className="p-3 bg-indigo-900/10 border border-indigo-500/20 rounded-lg flex justify-between">
+                    <p className="text-xs text-indigo-300">Pending: {queueList.filter(x=>x.status==='Pending').length}</p>
+                    <p className="text-xs text-indigo-300">Total: {queueList.length}</p>
+                 </div>
+               </div>
+            )}
+            
+            <div className="flex items-center gap-2 mt-4 bg-slate-900 p-2 rounded border border-slate-800">
+               <input type="checkbox" name="include_comments" id="include_comments" value="true" className="rounded bg-slate-800 border-slate-700 text-indigo-500 focus:ring-offset-0 focus:ring-0" />
+               <label htmlFor="include_comments" className="text-xs text-slate-400 select-none cursor-pointer">Include Reasoning (Detailed Schema)</label>
+            </div>
+          </form>
+        </div>
+
+        <div className="p-6 border-t border-slate-800/60 bg-[#0c0c0e]">
+           {activeTab === 'queue' ? (
+              <div className="flex gap-2">
+                 <button onClick={handleStartQueue} disabled={isProcessing} className={`flex-1 py-3 rounded-lg font-bold text-xs flex items-center justify-center gap-2 ${isProcessing ? 'bg-slate-800 text-slate-400' : 'bg-emerald-600 hover:bg-emerald-500 text-white'}`}>
+                    <Play className="w-4 h-4" /> Start Batch
+                 </button>
+                 {isProcessing && (
+                     <button onClick={handleStopQueue} className="px-4 bg-red-900/50 text-red-400 border border-red-900 rounded-lg hover:bg-red-900/80">
+                        <StopCircle className="w-4 h-4" />
+                     </button>
+                 )}
+              </div>
+           ) : activeTab === 'manual' ? (
+             <button type="submit" form="control-form" className="w-full py-3 bg-indigo-600 hover:bg-indigo-500 rounded-lg text-xs font-bold text-white flex justify-center gap-2"><Play className="w-4 h-4"/> Run Labeler</button>
+           ) : (
+             <button onClick={() => setRefreshTrigger(x=>x+1)} className="w-full py-3 bg-slate-800 hover:bg-slate-700 rounded-lg text-xs font-bold text-white">Refresh List</button>
+           )}
+        </div>
+      </div>
+
+      {/* RIGHT PANEL */}
+      <div className="flex-1 flex flex-col bg-[#09090b] overflow-hidden relative">
+         <div className="h-16 border-b border-slate-800/60 bg-[#09090b]/80 backdrop-blur flex justify-between items-center px-8 z-10">
+            <span className="text-xs font-mono font-medium text-slate-400 tracking-wide">{activeTab.toUpperCase()} VIEW</span>
+            <button onClick={() => setLogs('')} className="text-[10px] text-slate-600 hover:text-slate-400">Clear Logs</button>
+         </div>
+
+         <div className="flex-1 p-6 overflow-hidden flex flex-col z-10">
+            {activeTab === 'queue' && (
+                <div className="flex-1 flex flex-col gap-4">
+                    <div className="h-1/2 bg-slate-900/30 border border-slate-800 rounded-xl overflow-auto custom-scrollbar">
+                        <table className="w-full text-left text-xs text-slate-400">
+                            <thead className="bg-slate-900 text-slate-300 sticky top-0"><tr><th className="p-3">Link</th><th className="p-3">Ingested</th><th className="p-3">Status</th><th className="p-3 text-right">Action</th></tr></thead>
+                            <tbody className="divide-y divide-slate-800/50">
+                                {queueList.map((q,i) => (
+                                    <tr key={i} className="hover:bg-white/5">
+                                        <td className="p-3 truncate max-w-[300px] text-sky-500">
+                                            <a href={q.link} target="_blank" rel="noopener noreferrer" className="hover:underline flex items-center gap-1">
+                                                {q.link} <ExternalLink className="w-3 h-3"/>
+                                            </a>
+                                        </td>
+                                        <td className="p-3 text-slate-500">{q.timestamp}</td>
+                                        <td className="p-3"><span className={`px-2 py-0.5 rounded ${q.status==='Processed' ? 'bg-emerald-500/10 text-emerald-500' : 'bg-amber-500/10 text-amber-500'}`}>{q.status}</span></td>
+                                        <td className="p-3 text-right">
+                                            <button onClick={()=>handleQueueDelete(q.link)} className="text-slate-500 hover:text-red-500 p-1">
+                                                <Trash2 className="w-4 h-4"/>
+                                            </button>
+                                        </td>
+                                    </tr>
+                                ))}
+                                {queueList.length===0 && <tr><td colSpan={4} className="p-4 text-center">Queue empty. Upload CSV or use Extension.</td></tr>}
+                            </tbody>
+                        </table>
+                    </div>
+                    <div className="h-1/2 bg-black/40 border border-slate-800 rounded-xl p-4 font-mono text-[11px] text-slate-300 overflow-auto">
+                        <pre>{logs}</pre>
+                        <div ref={logEndRef} />
+                    </div>
+                </div>
+            )}
+
+            {activeTab === 'analytics' && (
+                <div className="flex-1 overflow-auto custom-scrollbar flex flex-col gap-6">
+                    {/* Header Stats */}
+                    <div className="grid grid-cols-4 gap-4">
+                        <div className="bg-slate-900 border border-slate-800 rounded-lg p-4">
+                            <h4 className="text-xs text-slate-500 uppercase font-bold">Total Verified</h4>
+                            <div className="text-2xl font-bold text-white mt-1">{comparisonList.length}</div>
+                        </div>
+                        <div className="bg-slate-900 border border-slate-800 rounded-lg p-4">
+                            <h4 className="text-xs text-slate-500 uppercase font-bold">MAE (Mean Err)</h4>
+                            <div className="text-2xl font-bold text-sky-400 mt-1">{stats.avgMAE}</div>
+                            <div className="text-[10px] text-slate-500">Average absolute deviation</div>
+                        </div>
+                        <div className="bg-slate-900 border border-slate-800 rounded-lg p-4">
+                            <h4 className="text-xs text-slate-500 uppercase font-bold">AI Bias</h4>
+                            <div className="text-2xl font-bold text-amber-400 mt-1">{Number(stats.bias) > 0 ? "+" : ""}{stats.bias}</div>
+                            <div className="text-[10px] text-slate-500">Positive = AI scores higher than human</div>
+                        </div>
+                    </div>
+
+                    {/* Comparison Chart List */}
+                    <div className="bg-slate-900/30 border border-slate-800 rounded-xl overflow-hidden">
+                       <div className="p-4 bg-slate-950 border-b border-slate-800 flex justify-between items-center">
+                            <h3 className="text-sm font-bold text-white flex items-center gap-2">
+                                <Scale className="w-4 h-4 text-indigo-500"/> Verification Showcase
+                            </h3>
+                       </div>
+                       <table className="w-full text-left text-xs text-slate-400">
+                           <thead className="bg-slate-900 text-slate-300">
+                               <tr>
+                                   <th className="p-3 w-1/4">Video / Link</th>
+                                   <th className="p-3 w-1/2">Score Comparison (AI vs Manual)</th>
+                                   <th className="p-3 text-right">Delta</th>
+                               </tr>
+                           </thead>
+                           <tbody className="divide-y divide-slate-800/50">
+                               {comparisonList.map((item, i) => (
+                                   <tr key={i} className="hover:bg-white/5">
+                                       <td className="p-3">
+                                           <div className="text-sky-500 truncate max-w-[200px]" title={item.link}>
+                                               <a href={item.link} target="_blank" rel="noopener noreferrer" className="hover:underline flex items-center gap-1">
+                                                   {item.link} <ExternalLink className="w-3 h-3"/>
+                                               </a>
+                                           </div>
+                                           <div className="text-[10px] text-slate-600 font-mono">{item.id}</div>
+                                       </td>
+                                       <td className="p-3">
+                                           {/* Visual Integrity Bar */}
+                                           <div className="flex items-center gap-2 mb-1">
+                                               <span className="w-16 text-[10px] text-slate-500">Visual</span>
+                                               <div className="flex-1 h-2 bg-slate-800 rounded-full overflow-hidden flex relative">
+                                                   <div className="absolute top-0 bottom-0 bg-indigo-500/50" style={{left:0, width:`${item.scores.visual.ai * 10}%`}}></div>
+                                                   <div className="absolute top-0 bottom-0 border-l-2 border-emerald-500 h-full" style={{left:`${item.scores.visual.manual * 10}%`}}></div>
+                                               </div>
+                                               <span className="text-[10px] font-mono"><span className="text-indigo-400">{item.scores.visual.ai}</span> / <span className="text-emerald-400">{item.scores.visual.manual}</span></span>
+                                           </div>
+                                            {/* Final Veracity Bar */}
+                                           <div className="flex items-center gap-2">
+                                               <span className="w-16 text-[10px] text-slate-500 font-bold">Final</span>
+                                               <div className="flex-1 h-3 bg-slate-800 rounded-full overflow-hidden flex relative">
+                                                   {/* AI Score */}
+                                                   <div className="bg-indigo-600 h-full" style={{width:`${item.scores.final.ai}%`}}></div>
+                                               </div>
+                                                {/* Manual Marker */}
+                                               <div className="w-1 h-3 bg-emerald-500 -ml-1 z-10"></div>
+                                               <span className="text-[10px] font-mono"><span className="text-indigo-400">{item.scores.final.ai}</span> / <span className="text-emerald-400">{item.scores.final.manual}</span></span>
+                                           </div>
+                                       </td>
+                                       <td className="p-3 text-right">
+                                           <div className={`font-bold ${Math.abs(item.deltas.final) > 20 ? 'text-red-500' : 'text-slate-400'}`}>
+                                               {item.deltas.final > 0 ? "+" : ""}{item.deltas.final}
+                                           </div>
+                                       </td>
+                                   </tr>
+                               ))}
+                           </tbody>
+                       </table>
+                    </div>
+                </div>
+            )}
+
+            {activeTab === 'workflow' && (
+                <div className="flex-1 overflow-auto custom-scrollbar flex flex-col gap-6">
+                   
+                   {/* Summary Cards */}
+                   <div className="grid grid-cols-3 gap-4">
+                       <div className="bg-slate-900 border border-slate-800 rounded-lg p-4">
+                           <h4 className="text-xs text-slate-500 uppercase font-bold">Pending Manual Review</h4>
+                           <div className="text-2xl font-bold text-white mt-1">{pendingVerification.length}</div>
+                           <div className="text-[10px] text-amber-500 mt-1">Ready for verification</div>
+                       </div>
+                       <div className="bg-slate-900 border border-slate-800 rounded-lg p-4">
+                           <h4 className="text-xs text-slate-500 uppercase font-bold">Ingestion Queue</h4>
+                           <div className="text-2xl font-bold text-white mt-1">{pendingAI.length}</div>
+                           <div className="text-[10px] text-sky-500 mt-1">Waiting for AI labeling</div>
+                       </div>
+                       <div className="bg-slate-900 border border-slate-800 rounded-lg p-4">
+                           <h4 className="text-xs text-slate-500 uppercase font-bold">Total Verified</h4>
+                           <div className="text-2xl font-bold text-white mt-1">{completed.length}</div>
+                           <div className="text-[10px] text-emerald-500 mt-1">Manually confirmed</div>
+                       </div>
+                   </div>
+
+                   {/* Main Section: Ready for Manual Verification */}
+                   <div className="bg-slate-900/30 border border-slate-800 rounded-xl overflow-hidden flex flex-col min-h-[300px]">
+                       <div className="p-4 bg-slate-950 border-b border-slate-800 flex justify-between items-center">
+                            <h3 className="text-sm font-bold text-white flex items-center gap-2">
+                                <AlertCircle className="w-4 h-4 text-amber-500"/> Needs Verification (Priority)
+                            </h3>
+                            <span className="text-xs text-slate-500">AI labeled links missing manual review.</span>
+                       </div>
+                       <div className="flex-1 overflow-auto">
+                        <table className="w-full text-left text-xs text-slate-400">
+                                <thead className="bg-slate-900 text-slate-300 sticky top-0">
+                                <tr>
+                                    <th className="p-4">Link</th>
+                                    <th className="p-4">AI Score</th>
+                                    <th className="p-4 text-right">Action</th>
+                                </tr>
+                                </thead>
+                                <tbody className="divide-y divide-slate-800/50">
+                                {pendingVerification.map((row, i) => (
+                                    <tr key={i} className="hover:bg-white/5 cursor-pointer" onClick={() => openLabelingModal(row)}>
+                                        <td className="p-4 truncate max-w-[400px] text-sky-400">
+                                            <a href={row.link} target="_blank" rel="noopener noreferrer" onClick={(e) => e.stopPropagation()} className="hover:underline flex items-center gap-1">
+                                                {row.link} <ExternalLink className="w-3 h-3"/>
+                                            </a>
+                                        </td>
+                                        <td className="p-4">
+                                            <span className="flex items-center gap-1 text-emerald-400">
+                                                <BrainCircuit className="w-3 h-3"/> {row.ai_data?.final}
+                                            </span>
+                                        </td>
+                                        <td className="p-4 text-right">
+                                            <button className="px-4 py-1.5 bg-indigo-600 text-white rounded font-bold hover:bg-indigo-500 shadow-lg shadow-indigo-500/20">Verify</button>
+                                        </td>
+                                    </tr>
+                                ))}
+                                {pendingVerification.length === 0 && (
+                                    <tr><td colSpan={3} className="p-8 text-center text-emerald-500">No pending verifications. Good job!</td></tr>
+                                )}
+                                </tbody>
+                        </table>
+                       </div>
+                   </div>
+
+                   {/* Secondary: Ingestion Queue */}
+                   <div className="bg-slate-900/30 border border-slate-800 rounded-xl overflow-hidden">
+                       <div className="p-3 bg-slate-950/50 border-b border-slate-800">
+                            <h3 className="text-xs font-bold text-slate-400 uppercase">Ingestion Queue (Waiting for AI)</h3>
+                       </div>
+                       <table className="w-full text-left text-xs text-slate-500">
+                            <tbody className="divide-y divide-slate-800/50">
+                            {pendingAI.slice(0, 10).map((row, i) => (
+                                <tr key={i}>
+                                    <td className="p-3 truncate max-w-[400px] opacity-60">
+                                        <a href={row.link} target="_blank" rel="noopener noreferrer" className="hover:underline hover:text-sky-400 flex items-center gap-1">
+                                            {row.link} <ExternalLink className="w-3 h-3"/>
+                                        </a>
+                                    </td>
+                                    <td className="p-3 text-right">
+                                        <span className="px-2 py-0.5 bg-slate-800 rounded text-slate-400">Pending AI</span>
+                                    </td>
+                                </tr>
+                            ))}
+                            {pendingAI.length > 10 && <tr><td colSpan={2} className="p-3 text-center opacity-50">...and {pendingAI.length - 10} more</td></tr>}
+                            </tbody>
+                       </table>
+                   </div>
+
+                   {/* Verified History */}
+                   <div className="bg-slate-900/30 border border-slate-800 rounded-xl overflow-hidden mb-8">
+                       <div className="p-3 bg-slate-950/50 border-b border-slate-800">
+                            <h3 className="text-xs font-bold text-slate-400 uppercase">Verification History</h3>
+                       </div>
+                       <table className="w-full text-left text-xs text-slate-500">
+                            <tbody className="divide-y divide-slate-800/50">
+                            {completed.slice(0, 10).map((row, i) => (
+                                <tr key={i}>
+                                    <td className="p-3 truncate max-w-[400px] opacity-60 text-emerald-500/50">
+                                        <a href={row.link} target="_blank" rel="noopener noreferrer" className="hover:underline hover:text-emerald-400 flex items-center gap-1">
+                                            {row.link} <ExternalLink className="w-3 h-3"/>
+                                        </a>
+                                    </td>
+                                    <td className="p-3 opacity-60">Tags: {row.manual_tags || "-"}</td>
+                                    <td className="p-3 text-right">
+                                        <CheckSquare className="w-4 h-4 text-emerald-600 inline"/>
+                                    </td>
+                                </tr>
+                            ))}
+                            </tbody>
+                       </table>
+                   </div>
+                </div>
+            )}
+
+            {activeTab === 'moderation' && (
+                <div className="flex-1 bg-slate-900/30 border border-slate-800 rounded-xl overflow-auto custom-scrollbar">
+                   <table className="w-full text-left text-xs text-slate-400">
+                        <thead className="bg-slate-900 text-slate-300 sticky top-0">
+                           <tr><th className="p-4">ID / Source</th><th className="p-4">Link / Caption</th><th className="p-4">Scores (V/A/F)</th><th className="p-4">Status</th><th className="p-4 text-right">Action</th></tr>
+                        </thead>
+                        <tbody className="divide-y divide-slate-800/50">
+                           {dataList.map((row, i) => (
+                             <React.Fragment key={i}>
+                               <tr onClick={() => setExpandedRow(expandedRow === row.id ? null : row.id)} className={`hover:bg-white/5 cursor-pointer ${expandedRow===row.id?'bg-white/5':''}`}>
+                                 <td className="p-4">
+                                     <div className="font-mono text-indigo-400 font-bold">{row.id || 'N/A'}</div>
+                                     <span className="text-[9px] uppercase px-1.5 py-0.5 rounded bg-slate-800 text-slate-500">{row.source_type}</span>
+                                 </td>
+                                 <td className="p-4">
+                                     <div className="truncate max-w-[250px] text-white mb-1" title={row.caption}>{row.caption || 'No Caption'}</div>
+                                     <div className="truncate max-w-[250px] text-[10px] text-slate-600">
+                                        <a href={row.link} target="_blank" rel="noopener noreferrer" onClick={(e) => e.stopPropagation()} className="hover:text-indigo-400 hover:underline flex items-center gap-1">
+                                             {row.link} <ExternalLink className="w-3 h-3"/>
+                                        </a>
+                                     </div>
+                                     {row.tags && <div className="mt-1 text-[9px] text-emerald-400 font-mono">{row.tags}</div>}
+                                 </td>
+                                 <td className="p-4 font-mono">
+                                     <span title="Visual" className="text-emerald-400">{row.visual_integrity_score}</span> / 
+                                     <span title="Audio" className="text-sky-400">{row.audio_integrity_score}</span> / 
+                                     <span title="Final" className="text-white font-bold">{row.final_veracity_score}</span>
+                                 </td>
+                                 <td className="p-4">
+                                     {row.source_type === 'auto' && (
+                                         row.manual_verification_status === 'Verified' ?
+                                         <span className="text-emerald-500 flex items-center gap-1"><CheckCircle className="w-3 h-3"/> Verified</span> :
+                                         <div className="flex items-center gap-2">
+                                            <span className="text-amber-500">Need Manual</span>
+                                            <button onClick={(e) => { e.stopPropagation(); openLabelingModal(row); }} 
+                                                className="px-2 py-1 bg-indigo-600 hover:bg-indigo-500 text-white rounded text-[10px]">
+                                                Verify
+                                            </button>
+                                         </div>
+                                     )}
+                                 </td>
+                                 <td className="p-4 text-right"><button onClick={(e)=>{e.stopPropagation(); handleDelete(row.id, row.link)}} className="hover:text-red-400 p-2"><Trash2 className="w-4 h-4"/></button></td>
+                               </tr>
+                               {expandedRow === row.id && (
+                                   <tr><td colSpan={5} className="bg-slate-950 p-6 border-b border-slate-800">
+                                      <div className="grid grid-cols-2 gap-6">
+                                         <div className="space-y-4">
+                                             <div>
+                                                 <h4 className="text-indigo-400 text-[10px] font-bold uppercase mb-2">Prompt Used</h4>
+                                                 <div className="bg-black/30 border border-slate-800 rounded p-2 h-32 overflow-auto text-[9px] font-mono text-slate-500">
+                                                     {row.json_data?.meta_info?.prompt_used || "Prompt not saved in legacy data."}
+                                                 </div>
+                                             </div>
+                                             <div>
+                                                 <h4 className="text-indigo-400 text-[10px] font-bold uppercase mb-2">Reasoning</h4>
+                                                 <p className="text-sm text-slate-300 italic">{row.final_reasoning}</p>
+                                             </div>
+                                         </div>
+                                         <div>
+                                             <h4 className="text-indigo-400 text-[10px] font-bold uppercase mb-2">Raw JSON Data</h4>
+                                             <div className="h-[300px] overflow-auto border border-slate-800 rounded p-3 bg-black/50 custom-scrollbar">
+                                                 <pre className="text-[10px] font-mono text-emerald-500">{JSON.stringify(row.json_data || row, null, 2)}</pre>
+                                             </div>
+                                         </div>
+                                      </div>
+                                   </td></tr>
+                               )}
+                             </React.Fragment>
+                           ))}
+                        </tbody>
+                   </table>
+                </div>
+            )}
+
+            {activeTab === 'manual' && (
+                <div className="flex-1 bg-black/40 border border-slate-800 rounded-xl p-4 font-mono text-[11px] text-slate-300 overflow-auto">
+                    <pre>{logs}</pre>
+                    <div ref={logEndRef} />
+                </div>
+            )}
+         </div>
+
+         {/* MANUAL LABELING MODAL */}
+         {labelingItem && (
+             <div className="absolute inset-0 z-50 bg-black/80 backdrop-blur-sm flex items-center justify-center p-8">
+                 <div className="bg-[#0f172a] border border-slate-700 rounded-xl w-full max-w-4xl h-full max-h-full overflow-y-auto shadow-2xl flex flex-col">
+                     <div className="p-4 border-b border-slate-800 flex justify-between items-center bg-[#1e293b]">
+                         <h2 className="text-lg font-bold text-white">Manual Verification</h2>
+                         <button onClick={() => setLabelingItem(null)} className="text-slate-400 hover:text-white"><XCircle className="w-6 h-6"/></button>
+                     </div>
+                     <div className="p-6 flex-1 overflow-y-auto">
+                         <div className="mb-6 bg-slate-900 p-4 rounded border border-slate-800">
+                             <div className="flex items-center gap-2 mb-2">
+                                <a href={labelingItem.link} target="_blank" rel="noopener noreferrer" className="text-xs text-indigo-400 font-mono hover:underline flex items-center gap-2">
+                                     {labelingItem.link} <ExternalLink className="w-3 h-3"/>
+                                </a>
+                             </div>
+                             {labelingItem.ai_data?.reasoning && (
+                                 <div className="text-xs text-slate-500 italic border-l-2 border-indigo-500 pl-3">
+                                     "AI Reasoning: {labelingItem.ai_data.reasoning}"
+                                 </div>
+                             )}
+                             {!labelingItem.ai_data && labelingItem.final_reasoning && (
+                                 <div className="text-xs text-slate-500 italic border-l-2 border-indigo-500 pl-3">
+                                     "AI Reasoning: {labelingItem.final_reasoning}"
+                                 </div>
+                             )}
+                         </div>
+
+                         <div className="grid grid-cols-2 gap-8">
+                             <div className="space-y-4">
+                                 <h3 className="text-xs font-bold text-slate-400 uppercase">Veracity Vectors (1-10)</h3>
+                                 {['visual', 'audio', 'source', 'logic'].map(k => (
+                                     <div key={k} className="flex items-center gap-4">
+                                         <label className="w-24 text-xs capitalize text-slate-300">{k}</label>
+                                         <input type="range" min="1" max="10" value={(manualForm as any)[k]} 
+                                            onChange={e => setManualForm({...manualForm, [k]: parseInt(e.target.value)})} 
+                                            className="flex-1 accent-indigo-500" />
+                                         <span className="w-6 text-center text-sm font-bold text-indigo-400">{(manualForm as any)[k]}</span>
+                                     </div>
+                                 ))}
+                                 
+                                 <h3 className="text-xs font-bold text-slate-400 uppercase mt-6">Modalities (1-10)</h3>
+                                 {['va', 'vc', 'ac'].map(k => (
+                                     <div key={k} className="flex items-center gap-4">
+                                         <label className="w-24 text-xs uppercase text-slate-300">{k}</label>
+                                         <input type="range" min="1" max="10" value={(manualForm as any)[k]} 
+                                            onChange={e => setManualForm({...manualForm, [k]: parseInt(e.target.value)})} 
+                                            className="flex-1 accent-emerald-500" />
+                                         <span className="w-6 text-center text-sm font-bold text-emerald-400">{(manualForm as any)[k]}</span>
+                                     </div>
+                                 ))}
+                             </div>
+
+                             <div className="space-y-4">
+                                 <div>
+                                     <label className="text-xs font-bold text-slate-400 uppercase block mb-2">Final Veracity Score (1-100)</label>
+                                     <div className="flex items-center gap-4">
+                                         <input type="range" min="1" max="100" value={manualForm.final} 
+                                            onChange={e => setManualForm({...manualForm, final: parseInt(e.target.value)})} 
+                                            className="flex-1 accent-amber-500 h-2" />
+                                         <span className="text-xl font-bold text-amber-500">{manualForm.final}</span>
+                                     </div>
+                                 </div>
+
+                                 <div>
+                                     <label className="text-xs font-bold text-slate-400 uppercase block mb-2">Reasoning</label>
+                                     <textarea className="w-full bg-slate-900 border border-slate-700 rounded p-3 text-xs text-white h-24"
+                                         value={manualForm.reasoning} onChange={e => setManualForm({...manualForm, reasoning: e.target.value})}
+                                         placeholder="Why did you assign these scores?"
+                                     />
+                                 </div>
+
+                                 <div>
+                                     <label className="text-xs font-bold text-slate-400 uppercase block mb-2">Tags (comma separated)</label>
+                                     <input type="text" className="w-full bg-slate-900 border border-slate-700 rounded p-3 text-xs text-white"
+                                         value={manualForm.tags} onChange={e => setManualForm({...manualForm, tags: e.target.value})}
+                                         placeholder="political, viral, deepfake..."
+                                     />
+                                 </div>
+                             </div>
+                         </div>
+                     </div>
+                     <div className="p-4 border-t border-slate-800 bg-[#1e293b] flex justify-end gap-3">
+                         <button onClick={() => setLabelingItem(null)} className="px-4 py-2 text-slate-400 hover:text-white">Cancel</button>
+                         <button onClick={submitManualLabel} className="px-6 py-2 bg-indigo-600 hover:bg-indigo-500 text-white font-bold rounded">Save Manual Label</button>
+                     </div>
+                 </div>
+             </div>
+         )}
+      </div>
+    </div>
+  )
+}
+
+export default App

frontend/src/index.css

@@ -0,0 +1,25 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+body {
+  background-color: #0f172a;
+  color: #e2e8f0;
+  font-family: 'Inter', sans-serif;
+  overflow: hidden;
+}
+
+/* Custom Scrollbar */
+::-webkit-scrollbar {
+  width: 8px;
+}
+::-webkit-scrollbar-track {
+  background: #1e293b; 
+}
+::-webkit-scrollbar-thumb {
+  background: #475569; 
+  border-radius: 4px;
+}
+::-webkit-scrollbar-thumb:hover {
+  background: #64748b; 
+}

frontend/src/main.tsx

@@ -0,0 +1,10 @@
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './App.tsx'
+import './index.css'
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+)

frontend/tailwind.config.js

@@ -0,0 +1,20 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: [
+    "./index.html",
+    "./src/**/*.{js,ts,jsx,tsx}",
+  ],
+  theme: {
+    extend: {
+      colors: {
+        'vchat-bg': '#0f172a',
+        'vchat-panel': '#1e293b',
+        'vchat-accent': '#6366f1',
+      },
+      animation: {
+        'pulse-slow': 'pulse 3s cubic-bezier(0.4, 0, 0.6, 1) infinite',
+      }
+    },
+  },
+  plugins: [],
+}

frontend/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

frontend/tsconfig.node.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["vite.config.ts"]
+}

frontend/vite.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [react()],
+})

main.go

@@ -0,0 +1,62 @@
+package main
+
+import (
+	"log"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"os"
+	"strings"
+)
+
+func main() {
+	// Target Python FastAPI server (running locally in the container)
+	pythonTarget := "http://127.0.0.1:8001"
+	pythonURL, err := url.Parse(pythonTarget)
+	if err != nil {
+		log.Fatalf("Invalid Python target URL: %v", err)
+	}
+
+	// Create Reverse Proxy
+	proxy := httputil.NewSingleHostReverseProxy(pythonURL)
+
+	// FIXED: Point to the new location safe from Docker Volumes
+	staticPath := "/usr/share/vchat/static"
+	fs := http.FileServer(http.Dir(staticPath))
+
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		// Check if request is for the API
+		// Added /queue to the list so uploads and list fetches work
+		// ADDED: /workflow to fix JSON parse error in frontend
+		if strings.HasPrefix(r.URL.Path, "/process") ||
+			strings.HasPrefix(r.URL.Path, "/label_video") ||
+			strings.HasPrefix(r.URL.Path, "/batch_label") ||
+			strings.HasPrefix(r.URL.Path, "/model-architecture") ||
+			strings.HasPrefix(r.URL.Path, "/download-dataset") ||
+			strings.HasPrefix(r.URL.Path, "/extension") ||
+			strings.HasPrefix(r.URL.Path, "/manage") ||
+			strings.HasPrefix(r.URL.Path, "/workflow") ||
+			strings.HasPrefix(r.URL.Path, "/queue") {
+
+			log.Printf("Proxying %s to Python Backend...", r.URL.Path)
+			proxy.ServeHTTP(w, r)
+			return
+		}
+
+		// Check if file exists in static dir, otherwise serve index.html (SPA Routing)
+		path := staticPath + r.URL.Path
+		if _, err := os.Stat(path); os.IsNotExist(err) {
+			http.ServeFile(w, r, staticPath+"/index.html")
+			return
+		}
+
+		fs.ServeHTTP(w, r)
+	})
+
+	port := "8000"
+	log.Printf("vChat Modern Server listening on port %s", port)
+	log.Printf("Serving static files from %s", staticPath)
+	if err := http.ListenAndServe(":"+port, nil); err != nil {
+		log.Fatal(err)
+	}
+}

requirements.txt

@@ -0,0 +1,42 @@
+torch
+torchvision
+torchaudio
+# --- Core Server ---
+fastapi
+uvicorn[standard]
+python-multipart
+requests
+aiofiles
+jinja2
+
+# --- AI & Vision Processing ---
+transformers
+accelerate
+Pillow
+packaging
+av
+# Use headless to avoid installing X11/GL libraries in Docker
+opencv-python-headless
+decord
+imageio
+numpy
+einops
+
+# --- Google Cloud & APIs ---
+google-generativeai
+google-cloud-aiplatform
+google-genai
+google-adk
+# CORRECTED: The ML Croissant library package name
+mlcroissant
+
+# --- Fine-Tuning (LoRA/QLoRA) ---
+peft
+# Bitsandbytes 0.44+ 
+bitsandbytes
+trl
+datasets
+
+# --- Audio ---
+openai-whisper
+yt-dlp

src/agents.py

@@ -0,0 +1,153 @@
+from google.adk.agents import Agent, SequentialAgent, ParallelAgent, LoopAgent
+from google.adk.models import Gemini
+from google.genai import types, Client
+import logging
+from typing import Optional
+from functools import cached_property
+
+logger = logging.getLogger(__name__)
+
+# --- Custom Gemini Class for Explicit API Key ---
+class CustomGemini(Gemini):
+    api_key: Optional[str] = None
+    
+    @cached_property
+    def api_client(self) -> Client:
+        """Overrides the default api_client to use the provided API key."""
+        return Client(
+            api_key=self.api_key,
+            http_options=types.HttpOptions(
+                headers=self._tracking_headers(),
+                retry_options=self.retry_options,
+            )
+        )
+
+# --- Retry Configuration ---
+retry_config = types.HttpRetryOptions(
+    attempts=5,  # Maximum retry attempts
+    exp_base=7,  # Delay multiplier
+    initial_delay=1,
+    http_status_codes=[429, 500, 503, 504], # Retry on these HTTP errors
+)
+
+def get_video_analysis_system(api_key: Optional[str] = None, model_name: str = "gemini-2.1-flash-lite"):
+    """
+    Factory function to create a configured VideoAnalysisSystem.
+    """
+    
+    # Use the custom Gemini class with the provided API key
+    llm_model = CustomGemini(
+        model=model_name,
+        api_key=api_key,
+        retry_options=retry_config
+    )
+
+    # --- Individual Agents ---
+
+    # Context Summary Agent: Provides a neutral summary of the video content.
+    context_summary_agent = Agent(
+        name="ContextSummaryAgent",
+        model=llm_model,
+        instruction="""
+        <thinking>
+        1. Scan the video, caption, and transcript for key entities and events.
+        2. Identify the main narrative thread or objective of the content.
+        3. Synthesize the findings into a neutral, objective summary.
+        </thinking>
+        Output format: summary: text[1]{text}: "Summary text" """,
+    )
+
+    # Political Bias Agent: Identifies political leaning and quantifies bias.
+    political_bias_agent = Agent(
+        name="PoliticalBiasAgent",
+        model=llm_model,
+        instruction="""
+        <thinking>
+        1. Examine the language used for loaded terms or rhetorical devices.
+        2. Analyze the context of mentioned political figures or institutions.
+        3. Determine the leaning (Left/Right/Center) and evaluate the intensity of bias.
+        </thinking>
+        Output format: political_bias: details[1]{score,reasoning}: (Int),"Reasoning" """,
+    )
+
+    # Criticism Level Agent: Measures the degree of hostility or support in the tone.
+    criticism_level_agent = Agent(
+        name="CriticismLevelAgent",
+        model=llm_model,
+        instruction="""
+        <thinking>
+        1. Assess the emotional valence of the speaker and visual cues.
+        2. Identify instances of direct criticism, sarcasm, or praise.
+        3. Quantify the overall hostility level on a neutral-to-supportive scale.
+        </thinking>
+        Output format: criticism_level: details[1]{score,reasoning}: (Int),"Reasoning" """,
+    )
+
+    # Modalities Agent: Evaluates the consistency between video, audio, and text.
+    modalities_agent = Agent(
+        name="ModalitiesAgent",
+        model=llm_model,
+        instruction="""
+        <thinking>
+        1. Compare visual events with audio descriptions for sync issues or contradictions.
+        2. Verify if the user-provided caption accurately reflects the visual content.
+        3. Check the transcript against both the audio and the caption for discrepancies.
+        </thinking>
+        Output format: 
+        video_audio_pairing: details[1]{score,reasoning}: (Int),"Reasoning"
+        video_caption_pairing: details[1]{score,reasoning}: (Int),"Reasoning"
+        audio_caption_pairing: details[1]{score,reasoning}: (Int),"Reasoning" """,
+    )
+
+    # Disinformation Agent: Analyzes potential manipulation and threat levels.
+    disinformation_agent = Agent(
+        name="DisinformationAgent",
+        model=llm_model,
+        instruction="""
+        <thinking>
+        1. Search for signs of technical manipulation (deepfakes, AI artifacts).
+        2. Analyze the intent behind potential misinformation (Political/Commercial).
+        3. Evaluate the risk level and the specific threat vector used.
+        </thinking>
+        Output format: disinformation_analysis: details[1]{level,intent,threat_vector}: (Int),(Intent),(Vector) """,
+    )
+
+    # Sentiment Bias Agent: Captures the overall emotional tone and inherent bias.
+    sentiment_bias_agent = Agent(
+        name="SentimentBiasAgent",
+        model=llm_model,
+        instruction="""
+        <thinking>
+        1. Aggregate the emotional signals from the entire video duration.
+        2. Identify recurring biased patterns or slanted perspectives.
+        3. Synthesize a comprehensive overview of the sentiment and bias.
+        </thinking>
+        Output format: sentiment_and_bias: text[1]{text}: "Synthesis text" """,
+    )
+
+    # --- Agent Grouping ---
+
+    # The ParallelAgent runs all its sub-agents simultaneously.
+    analysis_team = ParallelAgent(
+        name="AnalysisTeam",
+        sub_agents=[
+            context_summary_agent,
+            political_bias_agent,
+            criticism_level_agent,
+            modalities_agent,
+            disinformation_agent,
+            sentiment_bias_agent
+        ],
+    )
+
+    # This SequentialAgent defines the high-level workflow.
+    system = SequentialAgent(
+        name="VideoAnalysisSystem",
+        sub_agents=[analysis_team],
+    )
+    
+    return system
+
+if __name__ == "__main__":
+    system = get_video_analysis_system()
+    print("Video Analysis Agent System created successfully.")

src/app.py

@@ -0,0 +1,987 @@
+import os
+import sys
+import asyncio
+import subprocess
+from pathlib import Path
+import logging
+import csv
+import io
+import datetime
+import json
+import hashlib
+import re
+from fastapi import FastAPI, Request, Form, UploadFile, File, Body, HTTPException
+from fastapi.responses import HTMLResponse, StreamingResponse, PlainTextResponse, Response, FileResponse, JSONResponse
+from fastapi.templating import Jinja2Templates
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+import yt_dlp
+import inference_logic
+import factuality_logic
+import transcription
+from factuality_logic import parse_vtt
+from toon_parser import parse_veracity_toon
+
+# --- Fix for Large CSV Fields ---
+try:
+    csv.field_size_limit(sys.maxsize)
+except OverflowError:
+    csv.field_size_limit(2147483647)
+
+try:
+    import mlcroissant as mlc
+    CROISSANT_AVAILABLE = True
+except ImportError:
+    try:
+        import croissant as mlc
+        CROISSANT_AVAILABLE = True
+    except ImportError:
+        mlc = None
+        CROISSANT_AVAILABLE = False
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+LITE_MODE = os.getenv("LITE_MODE", "false").lower() == "true"
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+STATIC_DIR = "static"
+if os.path.isdir("/usr/share/vchat/static"):
+    STATIC_DIR = "/usr/share/vchat/static"
+elif os.path.isdir("frontend/dist"):
+    STATIC_DIR = "frontend/dist"
+elif not os.path.isdir(STATIC_DIR):
+    os.makedirs(STATIC_DIR, exist_ok=True)
+    dummy_index = Path(STATIC_DIR) / "index.html"
+    if not dummy_index.exists():
+        dummy_index.write_text("<html><body>vChat Backend Running. Access via Port 8005 (Go Server).</body></html>")
+
+app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+templates = Jinja2Templates(directory=STATIC_DIR)
+
+os.makedirs("data/videos", exist_ok=True)
+os.makedirs("data", exist_ok=True)
+os.makedirs("data/labels", exist_ok=True)
+os.makedirs("data/prompts", exist_ok=True) 
+os.makedirs("data/responses", exist_ok=True)
+os.makedirs("metadata", exist_ok=True)
+
+STOP_QUEUE_SIGNAL = False
+
+# --- Helper: Robust CSV Reader ---
+def robust_read_csv(file_path: Path):
+    """
+    Reads a CSV file tolerantly. Yields dictionaries.
+    Handles 'line contains NUL', formatting errors, etc. by skipping bad rows.
+    """
+    if not file_path.exists():
+        return
+
+    with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
+        # Read header first
+        try:
+            reader = csv.DictReader(f)
+            # Iterate manually to catch errors per row
+            while True:
+                try:
+                    row = next(reader)
+                    yield row
+                except StopIteration:
+                    break
+                except csv.Error as e:
+                    logging.warning(f"CSV Parse Error in {file_path}: {e}")
+                    continue
+        except Exception as e:
+            logging.error(f"Failed to initialize CSV reader for {file_path}: {e}")
+            return
+
+def ensure_manual_dataset():
+    """Ensures the manual dataset file exists with headers."""
+    p = Path("data/manual_dataset.csv")
+    if not p.exists():
+        with open(p, 'w', newline='', encoding='utf-8') as f:
+            # Standard schema + manual specific fields
+            writer = csv.writer(f)
+            writer.writerow([
+                "id", "link", "caption", "collecttime", "source",
+                "visual_integrity_score", "audio_integrity_score", "source_credibility_score",
+                "logical_consistency_score", "emotional_manipulation_score",
+                "video_audio_score", "video_caption_score", "audio_caption_score",
+                "final_veracity_score", "final_reasoning",
+                "stats_likes", "stats_shares", "stats_comments", "stats_platform", "tags"
+            ])
+
+@app.on_event("startup")
+async def startup_event():
+    logging.info("Application starting up...")
+    ensure_manual_dataset()
+    if not LITE_MODE:
+        try:
+            inference_logic.load_models()
+            transcription.load_model()
+        except Exception as e:
+            logging.fatal(f"Could not load models. Error: {e}", exc_info=True)
+    else:
+        logging.info("Running in LITE mode.")
+
+@app.get("/", response_class=HTMLResponse)
+async def read_root(request: Request):
+    custom_model_available = False
+    if not LITE_MODE:
+        custom_model_available = inference_logic.peft_model is not None
+    if not (Path(STATIC_DIR) / "index.html").exists():
+        return HTMLResponse(content="Frontend not found. Please build frontend or access via Go server.", status_code=404)
+    return templates.TemplateResponse("index.html", {
+        "request": request,
+        "custom_model_available": custom_model_available,
+        "lite_mode": LITE_MODE
+    })
+
+@app.get("/model-architecture", response_class=PlainTextResponse)
+async def get_model_architecture():
+    if LITE_MODE: return "Running in LITE mode."
+    if inference_logic.base_model: return str(inference_logic.base_model)
+    return "Model not loaded."
+
+@app.get("/download-dataset")
+async def download_dataset():
+    file_path = Path("data/dataset.csv")
+    if file_path.exists():
+        return FileResponse(path=file_path, filename="dataset.csv", media_type='text/csv')
+    return Response("Dataset not found.", status_code=404)
+
+progress_message = ""
+def progress_hook(d):
+    global progress_message
+    if d['status'] == 'downloading':
+        progress_message = f"Downloading: {d.get('_percent_str', 'N/A')} at {d.get('_speed_str', 'N/A')}\r"
+    elif d['status'] == 'finished':
+        progress_message = f"\nDownload finished. Preparing video assets...\n"
+
+async def run_subprocess_async(command: list[str]):
+    process = await asyncio.create_subprocess_exec(*command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    stdout, stderr = await process.communicate()
+    if process.returncode != 0:
+        raise RuntimeError(f"Process failed:\n{stderr.decode()}")
+    return stdout.decode()
+
+def extract_tweet_id(url: str) -> str | None:
+    match = re.search(r"(?:twitter|x)\.com/[^/]+/status/(\d+)", url)
+    if match: return match.group(1)
+    return None
+
+def normalize_link(link: str) -> str:
+    """Standardize links for comparison."""
+    if not link: return ""
+    # Remove protocol and www to match robustly
+    s = link.split('?')[0].strip().rstrip('/').replace('http://', '').replace('https://', '').replace('www.', '')
+    return s
+
+def check_if_processed(link: str) -> bool:
+    target_id = extract_tweet_id(link)
+    link_clean = normalize_link(link)
+    
+    for filename in ["data/dataset.csv", "data/manual_dataset.csv"]:
+        path = Path(filename)
+        for row in robust_read_csv(path):
+            row_link = normalize_link(row.get('link', ''))
+            if row_link and row_link == link_clean: return True
+            
+            row_id = row.get('id', '')
+            if target_id and row_id == target_id: return True
+    return False
+
+async def prepare_video_assets_async(url: str) -> dict:
+    global progress_message
+    loop = asyncio.get_event_loop()
+    is_local = not (url.startswith("http://") or url.startswith("https://"))
+    video_id = "unknown"
+    transcript_path = None
+    
+    if is_local:
+        original_path = Path(url)
+        if not original_path.exists(): raise FileNotFoundError(f"File not found: {url}")
+        video_id = hashlib.md5(str(url).encode('utf-8')).hexdigest()[:16]
+        metadata = {"id": video_id, "link": url, "caption": original_path.stem}
+    else:
+        tweet_id = extract_tweet_id(url)
+        video_id = tweet_id if tweet_id else hashlib.md5(url.encode('utf-8')).hexdigest()[:16]
+        sanitized_check = Path(f"data/videos/{video_id}_fixed.mp4")
+        
+        ydl_opts = {
+            'format': 'best[ext=mp4]/best', 
+            'outtmpl': 'data/videos/%(id)s.%(ext)s',
+            'progress_hooks': [progress_hook], 'quiet': True, 'noplaylist': True, 'no_overwrites': True,
+            'writesubtitles': True, 'writeautomaticsub': True, 'subtitleslangs': ['en']
+        }
+        
+        if sanitized_check.exists():
+            original_path = sanitized_check
+            metadata = {"id": video_id, "link": url, "caption": "Cached Video"}
+        else:
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                info = await loop.run_in_executor(None, lambda: ydl.extract_info(url, download=True))
+                original_path = Path(ydl.prepare_filename(info))
+                metadata = {
+                    "id": info.get("id", video_id), "link": info.get("webpage_url", url),
+                    "caption": info.get("description", info.get("title", "N/A")).encode('ascii', 'ignore').decode('ascii').strip()[:500],
+                    "postdatetime": info.get("upload_date", "N/A")
+                }
+                video_id = info.get("id", video_id)
+
+        transcript_path = next(Path("data/videos").glob(f"{video_id}*.en.vtt"), None)
+        if not transcript_path: transcript_path = next(Path("data/videos").glob(f"{video_id}*.vtt"), None)
+
+    sanitized_path = Path(f"data/videos/{video_id}_fixed.mp4")
+    if not sanitized_path.exists() and original_path.exists():
+        await run_subprocess_async(["ffmpeg", "-i", str(original_path), "-c:v", "libx264", "-preset", "fast", "-crf", "23", "-c:a", "aac", "-y", str(sanitized_path)])
+
+    audio_path = sanitized_path.with_suffix('.wav')
+    if not audio_path.exists() and sanitized_path.exists():
+        try:
+            await run_subprocess_async(["ffmpeg", "-i", str(sanitized_path), "-vn", "-acodec", "pcm_s16le", "-ar", "16000", "-ac", "1", "-y", str(audio_path)])
+        except: pass
+    
+    if not transcript_path and audio_path.exists() and not LITE_MODE:
+        transcript_path = await loop.run_in_executor(None, transcription.generate_transcript, str(audio_path))
+
+    return {"video": str(sanitized_path), "transcript": str(transcript_path) if transcript_path else None, "metadata": metadata}
+
+def safe_int(value):
+    try:
+        clean = re.sub(r'[^\d]', '', str(value))
+        return int(clean) if clean else 0
+    except Exception:
+        return 0
+
+async def generate_and_save_croissant_metadata(row_data: dict) -> str:
+    try:
+        sanitized_data = {
+            "id": str(row_data.get("id", "")),
+            "link": str(row_data.get("link", "")),
+            "visual_integrity_score": safe_int(row_data.get("visual_integrity_score")),
+            "final_veracity_score": safe_int(row_data.get("final_veracity_score"))
+        }
+        video_id = sanitized_data["id"]
+        timestamp = datetime.datetime.now().strftime('%Y%m%d%H%M%S')
+        croissant_json = {
+          "@context": "https://schema.org/",
+          "@type": "Dataset",
+          "name": f"vchat-label-{video_id}",
+          "description": f"Veracity analysis labels for video {video_id}",
+          "url": sanitized_data["link"],
+          "variableMeasured": sanitized_data
+        }
+        path = Path("metadata") / f"{video_id}_{timestamp}.json"
+        path.write_text(json.dumps(croissant_json, indent=2))
+        return str(path)
+    except Exception:
+        return "N/A (Error)"
+
+async def get_labels_for_link(video_url: str, gemini_config: dict, vertex_config: dict, model_selection: str, include_comments: bool, reasoning_method: str = "cot"):
+    try:
+        yield f"Downloading assets for {video_url}..."
+        paths = await prepare_video_assets_async(video_url)
+        video_path = paths["video"]
+        transcript_text = parse_vtt(paths["transcript"]) if paths["transcript"] else "No transcript."
+        caption = paths["metadata"].get("caption", "")
+        
+        yield f"Assets ready. Running inference ({model_selection}, {reasoning_method.upper()})..."
+        final_labels = None
+        raw_toon = ""
+        prompt_used = ""
+        
+        pipeline = inference_logic.run_gemini_labeling_pipeline if model_selection == 'gemini' else inference_logic.run_vertex_labeling_pipeline
+        config = gemini_config if model_selection == 'gemini' else vertex_config
+        
+        async for msg in pipeline(video_path, caption, transcript_text, config, include_comments, reasoning_method):
+            if isinstance(msg, dict) and "parsed_data" in msg:
+                final_labels = msg["parsed_data"]
+                raw_toon = msg.get("raw_toon", "")
+                prompt_used = msg.get("prompt_used", "")
+            elif isinstance(msg, str): yield msg
+
+        if not final_labels: raise RuntimeError("No labels generated.")
+        
+        final_labels["meta_info"] = {
+            "prompt_used": prompt_used,
+            "model_selection": model_selection,
+            "reasoning_method": reasoning_method
+        }
+        
+        vec = final_labels.get("veracity_vectors", {})
+        mod = final_labels.get("modalities", {})
+        fin = final_labels.get("final_assessment", {})
+        tags = final_labels.get("tags", [])
+        
+        row = {
+            "id": paths["metadata"]["id"],
+            "link": paths["metadata"]["link"],
+            "caption": caption,
+            "postdatetime": paths["metadata"].get("postdatetime", ""),
+            "collecttime": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "videotranscriptionpath": paths["transcript"] or "",
+            "visual_integrity_score": vec.get("visual_integrity_score", "0"),
+            "audio_integrity_score": vec.get("audio_integrity_score", "0"),
+            "source_credibility_score": vec.get("source_credibility_score", "0"),
+            "logical_consistency_score": vec.get("logical_consistency_score", "0"),
+            "emotional_manipulation_score": vec.get("emotional_manipulation_score", "0"),
+            "video_audio_score": mod.get("video_audio_score", "0"),
+            "video_caption_score": mod.get("video_caption_score", "0"),
+            "audio_caption_score": mod.get("audio_caption_score", "0"),
+            "final_veracity_score": fin.get("veracity_score_total", "0"),
+            "final_reasoning": fin.get("reasoning", ""),
+            "tags": ", ".join(tags)
+        }
+        yield {"csv_row": row, "full_json": final_labels, "raw_toon": raw_toon}
+
+    except Exception as e:
+        yield {"error": str(e)}
+
+@app.get("/queue/list")
+async def get_queue_list():
+    queue_path = Path("data/batch_queue.csv")
+    items = []
+    
+    for row in robust_read_csv(queue_path):
+        if len(row) > 0:
+            link = row.get("link")
+            if not link: continue
+            status = "Processed" if check_if_processed(link) else "Pending"
+            items.append({
+                "link": link, 
+                "timestamp": row.get("ingest_timestamp", ""), 
+                "status": status
+            })
+    return items
+
+@app.delete("/queue/delete")
+async def delete_queue_item(link: str):
+    queue_path = Path("data/batch_queue.csv")
+    if not queue_path.exists():
+        return {"status": "error", "message": "Queue file not found"}
+    
+    rows = []
+    deleted = False
+    try:
+        # Read using robust reader to get clean data, but we need to write back using standard writer
+        # This implies we might lose bad rows if we rewrite.
+        # Strategy: Read all into memory, filter, write back.
+        
+        # Read header first to preserve it
+        with open(queue_path, 'r', encoding='utf-8', errors='replace') as f:
+            reader = csv.reader(f)
+            try: header = next(reader)
+            except StopIteration: header = ["link", "ingest_timestamp"]
+        
+        all_rows = list(robust_read_csv(queue_path))
+        new_rows = []
+        for row in all_rows:
+            if row.get("link") == link:
+                deleted = True
+            else:
+                new_rows.append(row)
+        
+        if deleted:
+            with open(queue_path, 'w', newline='', encoding='utf-8') as f:
+                writer = csv.DictWriter(f, fieldnames=header)
+                writer.writeheader()
+                writer.writerows(new_rows)
+            return {"status": "success", "link": link}
+        else:
+            return {"status": "not_found", "message": "Link not found in queue"}
+            
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+@app.post("/queue/stop")
+async def stop_queue_processing():
+    global STOP_QUEUE_SIGNAL
+    STOP_QUEUE_SIGNAL = True
+    return {"status": "stopping"}
+
+@app.post("/queue/upload_csv")
+async def upload_csv_to_queue(file: UploadFile = File(...)):
+    try:
+        content = await file.read()
+        decoded = content.decode('utf-8').splitlines()
+        reader = csv.reader(decoded)
+        links_to_add = []
+        header = next(reader, None)
+        if not header: return {"status": "empty file"}
+
+        link_idx = 0
+        header_lower = [h.lower() for h in header]
+        if "link" in header_lower: link_idx = header_lower.index("link")
+        elif "url" in header_lower: link_idx = header_lower.index("url")
+        elif "http" in header[0]: 
+            links_to_add.append(header[0])
+            link_idx = 0
+        
+        for row in reader:
+            if len(row) > link_idx and row[link_idx].strip():
+                links_to_add.append(row[link_idx].strip())
+
+        queue_path = Path("data/batch_queue.csv")
+        existing_links = set()
+        if queue_path.exists():
+            with open(queue_path, 'r', encoding='utf-8', errors='replace') as f:
+                existing_links = set(f.read().splitlines())
+
+        added_count = 0
+        with open(queue_path, 'a', newline='', encoding='utf-8') as f:
+            writer = csv.writer(f)
+            if not queue_path.exists() or queue_path.stat().st_size == 0:
+                writer.writerow(["link", "ingest_timestamp"])
+            
+            for link in links_to_add:
+                duplicate = False
+                for line in existing_links:
+                    if link in line: 
+                        duplicate = True
+                        break
+                if duplicate: continue
+
+                writer.writerow([link, datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")])
+                added_count += 1
+                
+        return {"status": "success", "added": added_count}
+    except Exception as e:
+        return JSONResponse(status_code=400, content={"error": str(e), "status": "failed"})
+
+@app.post("/queue/run")
+async def run_queue_processing(
+    model_selection: str = Form(...),
+    gemini_api_key: str = Form(""), gemini_model_name: str = Form(""),
+    vertex_project_id: str = Form(""), vertex_location: str = Form(""), vertex_model_name: str = Form(""), vertex_api_key: str = Form(""),
+    include_comments: bool = Form(False),
+    reasoning_method: str = Form("cot")
+):
+    global STOP_QUEUE_SIGNAL
+    STOP_QUEUE_SIGNAL = False
+    gemini_config = {"api_key": gemini_api_key, "model_name": gemini_model_name}
+    vertex_config = {"project_id": vertex_project_id, "location": vertex_location, "model_name": vertex_model_name, "api_key": vertex_api_key}
+    
+    async def queue_stream():
+        queue_path = Path("data/batch_queue.csv")
+        items = []
+        for row in robust_read_csv(queue_path):
+             l = row.get("link")
+             if l: items.append(l)
+        
+        if not items:
+            yield "data: Queue empty.\n\n"
+            return
+            
+        processed_count = 0
+        total = len(items)
+        
+        for i, link in enumerate(items):
+            if STOP_QUEUE_SIGNAL:
+                yield "data: [SYSTEM] Stopped by user.\n\n"
+                break
+            
+            if check_if_processed(link):
+                yield f"data: [SKIP] {link} processed.\n\n"
+                continue
+            
+            yield f"data: [START] {i+1}/{total}: {link}\n\n"
+            final_data = None
+            async for res in get_labels_for_link(link, gemini_config, vertex_config, model_selection, include_comments, reasoning_method):
+                if isinstance(res, str): yield f"data: {res}\n\n"
+                if isinstance(res, dict) and "csv_row" in res: final_data = res
+            
+            if final_data:
+                row = final_data["csv_row"]
+                vid_id = row["id"]
+                ts = datetime.datetime.now().strftime('%Y%m%d%H%M%S')
+                
+                # 1. Save JSON
+                json_path = f"data/labels/{vid_id}_{ts}_labels.json"
+                with open(json_path, 'w') as f: json.dump(final_data["full_json"], f, indent=2)
+                
+                # 2. Save TOON
+                with open(f"data/labels/{vid_id}_{ts}.toon", 'w') as f: f.write(final_data["raw_toon"])
+                
+                # 3. Save Prompt
+                prompt_content = final_data.get("full_json", {}).get("meta_info", {}).get("prompt_used", "")
+                if prompt_content:
+                    with open(f"data/prompts/{vid_id}_{ts}_prompt.txt", 'w', encoding='utf-8') as f:
+                        f.write(prompt_content)
+
+                # 4. Save Raw Response
+                raw_response = final_data.get("raw_toon", "")
+                if raw_response:
+                    with open(f"data/responses/{vid_id}.txt", 'w', encoding='utf-8') as f:
+                        f.write(raw_response)
+
+                row["metadatapath"] = await generate_and_save_croissant_metadata(row)
+                row["json_path"] = json_path
+                
+                # 5. Save to CSV
+                dpath = Path("data/dataset.csv")
+                exists = dpath.exists()
+                with open(dpath, 'a', newline='', encoding='utf-8') as f:
+                    writer = csv.DictWriter(f, fieldnames=list(row.keys()), extrasaction='ignore')
+                    if not exists: writer.writeheader()
+                    writer.writerow(row)
+                
+                processed_count += 1
+                yield f"data: [SUCCESS] Labeled.\n\n"
+            else:
+                yield f"data: [FAIL] Failed to label.\n\n"
+                
+        yield f"data: Batch Complete. +{processed_count} videos labeled.\n\n"
+        yield "event: close\ndata: Done\n\n"
+
+    return StreamingResponse(queue_stream(), media_type="text/event-stream")
+
+@app.post("/extension/ingest")
+async def extension_ingest(request: Request):
+    try:
+        data = await request.json()
+        link = data.get("link")
+        if not link: raise HTTPException(status_code=400, detail="No link")
+        queue_path = Path("data/batch_queue.csv")
+        file_exists = queue_path.exists()
+        
+        if file_exists:
+            with open(queue_path, 'r', encoding='utf-8', errors='replace') as f:
+                if link in f.read(): 
+                    return {"status": "queued", "msg": "Duplicate"}
+                    
+        with open(queue_path, 'a', newline='', encoding='utf-8') as f:
+            writer = csv.writer(f)
+            if not file_exists: writer.writerow(["link", "ingest_timestamp"])
+            writer.writerow([link, datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")])
+            
+        return {"status": "queued", "link": link}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/extension/save_comments")
+async def extension_save_comments(request: Request):
+    try:
+        data = await request.json()
+        link = data.get("link")
+        # Comments can be a list of strings (legacy) or objects (new)
+        comments = data.get("comments", [])
+        if not link or not comments: raise HTTPException(status_code=400, detail="Missing data")
+        
+        csv_path = Path("data/comments.csv")
+        exists = csv_path.exists()
+        
+        # Define fields for comment storage
+        fieldnames = ["link", "author", "comment_text", "timestamp"]
+        
+        with open(csv_path, 'a', newline='', encoding='utf-8') as f:
+            writer = csv.DictWriter(f, fieldnames=fieldnames, extrasaction='ignore')
+            if not exists: writer.writeheader()
+            
+            ts = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            for c in comments:
+                row = {"link": link, "timestamp": ts}
+                if isinstance(c, dict):
+                    row["author"] = c.get("author", "Unknown")
+                    row["comment_text"] = c.get("text", "").strip()
+                else:
+                    # Legacy string support
+                    row["author"] = "Unknown"
+                    row["comment_text"] = str(c).strip()
+                
+                if row["comment_text"]:
+                    writer.writerow(row)
+                    
+        return {"status": "saved", "count": len(comments)}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/extension/save_manual")
+async def extension_save_manual(request: Request):
+    try:
+        data = await request.json()
+        link = data.get("link")
+        labels = data.get("labels", {})
+        stats = data.get("stats", {})
+        tags = data.get("tags", "") # Accept tags string
+        
+        if not link: raise HTTPException(status_code=400, detail="No link")
+        
+        video_id = extract_tweet_id(link) or hashlib.md5(link.encode()).hexdigest()[:16]
+        
+        # Ensure manual dataset exists
+        ensure_manual_dataset()
+
+        # 1. Build row data for Manual Dataset
+        row_data = {
+            "id": video_id,
+            "link": link,
+            "caption": data.get("caption", ""),
+            "collecttime": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "source": "manual_extension",
+            
+            # Vectors
+            "visual_integrity_score": labels.get("visual_integrity_score", 0),
+            "audio_integrity_score": labels.get("audio_integrity_score", 0),
+            "source_credibility_score": labels.get("source_credibility_score", 0),
+            "logical_consistency_score": labels.get("logical_consistency_score", 0),
+            "emotional_manipulation_score": labels.get("emotional_manipulation_score", 0),
+            
+            # Modalities
+            "video_audio_score": labels.get("video_audio_score", 0),
+            "video_caption_score": labels.get("video_caption_score", 0),
+            "audio_caption_score": labels.get("audio_caption_score", 0),
+            
+            "final_veracity_score": labels.get("final_veracity_score", 0),
+            "final_reasoning": labels.get("reasoning", ""),
+            
+            # New Stats & Tags
+            "stats_likes": stats.get("likes", 0),
+            "stats_shares": stats.get("shares", 0),
+            "stats_comments": stats.get("comments", 0),
+            "stats_platform": stats.get("platform", "unknown"),
+            "tags": tags
+        }
+        
+        # Save to manual_dataset.csv using Upsert logic (Clean Dataset)
+        dpath = Path("data/manual_dataset.csv")
+        rows = []
+        replaced = False
+        
+        # Read existing
+        if dpath.exists():
+            rows = list(robust_read_csv(dpath))
+            
+        new_rows = []
+        for r in rows:
+            if r.get('id') == video_id:
+                new_rows.append(row_data) # Replace
+                replaced = True
+            else:
+                new_rows.append(r)
+        
+        if not replaced:
+            new_rows.append(row_data)
+            
+        # Write back all
+        with open(dpath, 'w', newline='', encoding='utf-8') as f:
+            writer = csv.DictWriter(f, fieldnames=list(row_data.keys()), extrasaction='ignore')
+            writer.writeheader()
+            writer.writerows(new_rows)
+
+        # 2. PERFORM COMPARISON AGAINST AI DATA
+        ai_path = Path("data/dataset.csv")
+        ai_data = None
+        if ai_path.exists():
+            for row in robust_read_csv(ai_path):
+                # Find by link or ID (Normalize first)
+                r_link = normalize_link(row.get('link', ''))
+                t_link = normalize_link(link)
+                
+                if r_link == t_link or row.get('id') == video_id:
+                    ai_data = row
+                    break
+        
+        if ai_data:
+            # Calculate Differences (AI - Manual)
+            comp_path = Path("data/comparison.csv")
+            comp_exists = comp_path.exists()
+            
+            # Helper to extract int safely
+            def get_int(d, k): 
+                try: 
+                    # sanitize weird strings like "(9)"
+                    val = str(d.get(k, 0))
+                    val = re.sub(r'[^\d]', '', val)
+                    return int(val) if val else 0
+                except: return 0
+
+            comparison_row = {
+                "id": video_id,
+                "link": link,
+                "timestamp": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                
+                # Visual
+                "ai_visual": get_int(ai_data, "visual_integrity_score"),
+                "manual_visual": row_data["visual_integrity_score"],
+                "delta_visual": get_int(ai_data, "visual_integrity_score") - row_data["visual_integrity_score"],
+
+                # Audio
+                "ai_audio": get_int(ai_data, "audio_integrity_score"),
+                "manual_audio": row_data["audio_integrity_score"],
+                "delta_audio": get_int(ai_data, "audio_integrity_score") - row_data["audio_integrity_score"],
+                
+                # Source
+                "ai_source": get_int(ai_data, "source_credibility_score"),
+                "manual_source": row_data["source_credibility_score"],
+                "delta_source": get_int(ai_data, "source_credibility_score") - row_data["source_credibility_score"],
+
+                # Logic
+                "ai_logic": get_int(ai_data, "logical_consistency_score"),
+                "manual_logic": row_data["logical_consistency_score"],
+                "delta_logic": get_int(ai_data, "logical_consistency_score") - row_data["logical_consistency_score"],
+
+                # Final
+                "ai_final": get_int(ai_data, "final_veracity_score"),
+                "manual_final": row_data["final_veracity_score"],
+                "delta_final": get_int(ai_data, "final_veracity_score") - row_data["final_veracity_score"]
+            }
+
+            # Upsert into comparison.csv as well
+            comp_rows = []
+            if comp_exists:
+                comp_rows = list(robust_read_csv(comp_path))
+            
+            final_comp_rows = []
+            comp_replaced = False
+            for cr in comp_rows:
+                if cr.get('id') == video_id:
+                    final_comp_rows.append(comparison_row)
+                    comp_replaced = True
+                else:
+                    final_comp_rows.append(cr)
+            if not comp_replaced:
+                final_comp_rows.append(comparison_row)
+                
+            with open(comp_path, 'w', newline='', encoding='utf-8') as f:
+                writer = csv.DictWriter(f, fieldnames=list(comparison_row.keys()), extrasaction='ignore')
+                writer.writeheader()
+                writer.writerows(final_comp_rows)
+            
+        return {"status": "saved", "compared": True if ai_data else False}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/workflow/status")
+async def get_workflow_status():
+    """
+    Returns a list of all known links (from queue and AI dataset),
+    indicating whether they have been Manually Labeled.
+    Matches primarily on ID (Tweet ID or Hash), falling back to Link.
+    """
+    all_links = {}
+
+    def get_canonical_key(link, rid=None):
+        # 1. Try Tweet ID extraction
+        tid = extract_tweet_id(link)
+        if tid: return tid
+        # 2. Use existing ID if valid
+        if rid and str(rid).strip(): return str(rid).strip()
+        # 3. Fallback to normalized link
+        return normalize_link(link)
+
+    # 1. Load Queue (Raw)
+    qp = Path("data/batch_queue.csv")
+    for row in robust_read_csv(qp):
+        url = row.get("link", "").strip()
+        if url:
+            # Queue doesn't usually have ID, so we rely on extraction or link
+            key = get_canonical_key(url)
+            all_links[key] = {
+                "link": url, "source": "queue", 
+                "ai_status": "Pending", "manual_status": "Pending",
+                "ai_data": None
+            }
+
+    # 2. Load AI Labels
+    dp = Path("data/dataset.csv")
+    for row in robust_read_csv(dp):
+        url = row.get("link", "").strip()
+        rid = row.get("id", "").strip()
+        
+        # If we have data, we definitely have a key
+        key = get_canonical_key(url, rid)
+        
+        if key not in all_links:
+            all_links[key] = {"link": url, "source": "dataset", "manual_status": "Pending"}
+        
+        all_links[key]["ai_status"] = "Labeled"
+        all_links[key]["ai_data"] = {
+            "visual": row.get("visual_integrity_score"),
+            "final": row.get("final_veracity_score"),
+            "reasoning": row.get("final_reasoning"),
+            "tags": row.get("tags", "")
+        }
+
+    # 3. Load Manual Labels
+    mp = Path("data/manual_dataset.csv")
+    for row in robust_read_csv(mp):
+        url = row.get("link", "").strip()
+        rid = row.get("id", "").strip()
+        
+        key = get_canonical_key(url, rid)
+        
+        if key in all_links:
+            all_links[key]["manual_status"] = "Completed"
+            all_links[key]["manual_tags"] = row.get("tags", "")
+        else:
+            # In case manual label exists without queue/AI entry
+            all_links[key] = {
+                "link": url, "source": "manual_only", 
+                "ai_status": "Unknown", "manual_status": "Completed",
+                "manual_tags": row.get("tags", "")
+            }
+
+    return list(all_links.values())
+
+@app.get("/manage/list")
+async def list_data():
+    data = []
+
+    # 1. Build Index of Manual Labels to check "Need Manual" status
+    manual_index = set()
+    mp = Path("data/manual_dataset.csv")
+    for row in robust_read_csv(mp):
+        if row.get('link'): manual_index.add(normalize_link(row['link']))
+        if row.get('id'): manual_index.add(row['id'].strip())
+
+    def read_csv(path, source_type):
+        for row in robust_read_csv(path):
+            if not row.get('id') or row['id'].strip() == "":
+                link = row.get('link', '')
+                tid = extract_tweet_id(link)
+                row['id'] = tid if tid else hashlib.md5(link.encode()).hexdigest()[:16]
+            
+            json_content = None
+            if row.get('json_path') and os.path.exists(row['json_path']):
+                    try:
+                        with open(row['json_path'], 'r') as jf: json_content = json.load(jf)
+                    except: pass
+            
+            row['source_type'] = source_type
+            row['json_data'] = json_content
+            
+            # NEW: Verification Status for AI rows
+            if source_type == "auto":
+                lid = row.get('id')
+                llink = normalize_link(row.get('link', ''))
+                if lid in manual_index or llink in manual_index:
+                    row['manual_verification_status'] = "Verified"
+                else:
+                    row['manual_verification_status'] = "Need Manual"
+            
+            data.append(row)
+
+    read_csv(Path("data/dataset.csv"), "auto")
+    read_csv(Path("data/manual_dataset.csv"), "manual")
+    data.sort(key=lambda x: x.get('collecttime', ''), reverse=True)
+    return data
+
+@app.get("/manage/comparison_data")
+async def get_comparison_data():
+    """
+    Returns an aggregated dataset joining AI Labels vs Manual Labels for visualization.
+    """
+    ai_data = {}
+    # Load AI Data
+    for row in robust_read_csv(Path("data/dataset.csv")):
+        # Key by ID or Link
+        key = row.get("id")
+        if not key: key = normalize_link(row.get("link"))
+        ai_data[key] = row
+    
+    comparisons = []
+    
+    # Load Manual Data and Match
+    for manual in robust_read_csv(Path("data/manual_dataset.csv")):
+        key = manual.get("id")
+        if not key: key = normalize_link(manual.get("link"))
+        
+        if key in ai_data:
+            ai = ai_data[key]
+            
+            def get_score(d, k):
+                try: 
+                    val = str(d.get(k, 0))
+                    val = re.sub(r'[^\d]', '', val) # strip non-digits
+                    return int(val) if val else 0
+                except: return 0
+            
+            item = {
+                "id": key,
+                "link": manual.get("link"),
+                "scores": {
+                    "visual": {"ai": get_score(ai, "visual_integrity_score"), "manual": get_score(manual, "visual_integrity_score")},
+                    "audio": {"ai": get_score(ai, "audio_integrity_score"), "manual": get_score(manual, "audio_integrity_score")},
+                    "final": {"ai": get_score(ai, "final_veracity_score"), "manual": get_score(manual, "final_veracity_score")}
+                }
+            }
+            # Calculate Delta (AI - Manual)
+            item["deltas"] = {
+                "visual": item["scores"]["visual"]["ai"] - item["scores"]["visual"]["manual"],
+                "audio": item["scores"]["audio"]["ai"] - item["scores"]["audio"]["manual"],
+                "final": item["scores"]["final"]["ai"] - item["scores"]["final"]["manual"]
+            }
+            comparisons.append(item)
+            
+    return comparisons
+
+@app.delete("/manage/delete")
+async def delete_data(id: str = "", link: str = ""):
+    if not id and not link: raise HTTPException(status_code=400, detail="Must provide ID or Link")
+    deleted_count = 0
+    target_id = id
+    
+    def remove_from_csv(path):
+        nonlocal deleted_count, target_id
+        if not path.exists(): return
+        
+        # We need to rewrite, so we read all then write back
+        rows = list(robust_read_csv(path))
+        
+        # We need headers for DictWriter, infer from first row or file check
+        fieldnames = []
+        with open(path, 'r', encoding='utf-8', errors='replace') as f:
+            reader = csv.DictReader(f)
+            fieldnames = reader.fieldnames
+            
+        new_rows = []
+        found_in_file = False
+        for row in rows:
+            is_match = False
+            if id and row.get('id') == id: is_match = True
+            elif link and normalize_link(row.get('link', '')) == normalize_link(link): is_match = True
+            
+            if is_match:
+                found_in_file = True
+                deleted_count += 1
+                if not target_id: target_id = row.get('id')
+            else:
+                new_rows.append(row)
+
+        if found_in_file and fieldnames:
+            with open(path, 'w', newline='', encoding='utf-8') as f:
+                writer = csv.DictWriter(f, fieldnames=fieldnames)
+                writer.writeheader()
+                writer.writerows(new_rows)
+
+    remove_from_csv(Path("data/dataset.csv"))
+    remove_from_csv(Path("data/manual_dataset.csv"))
+    if target_id:
+        for p in Path("data/labels").glob(f"{target_id}_*"): p.unlink(missing_ok=True)
+        for p in Path("metadata").glob(f"{target_id}_*"): p.unlink(missing_ok=True)
+    return {"status": "deleted", "count": deleted_count}
+
+@app.post("/label_video")
+async def label_video_endpoint(
+    video_url: str = Form(...), model_selection: str = Form(...),
+    gemini_api_key: str = Form(""), gemini_model_name: str = Form(""),
+    vertex_project_id: str = Form(""), vertex_location: str = Form(""), vertex_model_name: str = Form(""), vertex_api_key: str = Form(""),
+    include_comments: bool = Form(False),
+    reasoning_method: str = Form("cot")
+):
+    gemini_config = {"api_key": gemini_api_key, "model_name": gemini_model_name}
+    vertex_config = {"project_id": vertex_project_id, "location": vertex_location, "model_name": vertex_model_name, "api_key": vertex_api_key}
+    async def stream():
+        async for msg in get_labels_for_link(video_url, gemini_config, vertex_config, model_selection, include_comments, reasoning_method):
+             if isinstance(msg, str): yield f"data: {msg}\n\n"
+             if isinstance(msg, dict) and "csv_row" in msg: yield "data: Done. Labels generated.\n\n"
+        yield "event: close\ndata: Done.\n\n"
+    return StreamingResponse(stream(), media_type="text/event-stream")

src/croissant_transformer.py

@@ -0,0 +1,126 @@
+import pandas as pd
+import json
+import os
+import datetime
+
+# input dataframe row
+# output croissant json
+def Croissant_JSON_formating(row):
+    status_id = row['twitterlink'].split('/')[-1]
+
+    croissant_JSON = {
+        "@context": {
+            "@language": "en",
+            "@vocab": "https://schema.org/",
+            "cr": "http://mlcommons.org/croissant/1.0",
+            "sc": "https://schema.org/"
+        },
+        "@type": "sc:Dataset",
+        "name": f"Tweet-ID-{status_id}",
+        "description": f"A single social media video post(Tweet ID: {status_id}) by the user, structured as a Croissant Dataset.",
+        "url": row['twitterlink'],
+        "conformsTo": "http://mlcommons.org/croissant/1.0",
+        "datePublished": row['postdatetime'],
+        "creator": {
+            "@type": "sc:Organization",
+            "name": "Social Media Manually Collect Source"
+        },
+        "distribution": [
+            {
+            "@type": "cr:FileObject",
+            "name": f"source_tweet_url_{status_id}",
+            "encodingFormat": "text/html",
+            "contentUrl": row['twitterlink']
+            }
+        ],
+        
+        "recordSet": [
+            {
+            "@type": "cr:RecordSet",
+            "name": "tweet_data_record",
+            "description": "The specific data fields for this tweet.",
+            
+
+            "field": [
+                {
+                "@type": "cr:Field",
+                "name": "internal_id",
+                "description": "Internal record ID from the source CSV.",
+                "data_type": "sc:Integer",
+                "sc:value": int(row['id'])
+                },
+                {
+                "@type": "cr:Field",
+                "name": "tweet_text",
+                "description": "The full text/caption of the tweet.",
+                "data_type": "sc:Text",
+                "sc:value": row['caption']
+                },
+                {
+                "@type": "cr:Field",
+                "name": "likes_count",
+                "description": "Number of likes/favorites.",
+                "data_type": "sc:Integer",
+                "sc:value": int(row['likes'])
+                },
+                {
+                "@type": "cr:Field",
+                "name": "shares_count",
+                "description": "Number of shares/reposts.",
+                "data_type": "sc:Integer",
+                "sc:value": int(row['shares'])
+                },
+                {
+                "@type": "cr:Field",
+                "name": "post_timestamp",
+                "description": "When the tweet was posted (ISO 8601).",
+                "data_type": "sc:DateTime",
+                "sc:value": row['postdatetime']
+                },
+                {
+                "@type": "cr:Field",
+                "name": "collection_timestamp",
+                "description": "When this data was collected (ISO 8601).",
+                "data_type": "sc:DateTime",
+                "sc:value": row['collecttime']
+                },
+                {
+                "@type": "cr:Field",
+                "name": "video_transcript_path",
+                "description": "Path to the video transcription file.",
+                "data_type": "sc:Text",
+                "sc:value": row['videotranscriptionpath'] if pd.notna(row['videotranscriptionpath']) else ""
+                }
+            ]
+            }
+        ]
+        }
+    return croissant_JSON
+
+
+# input twitterVideo.csv file path
+# output folder "croissant_tweet_metadata" in current directory
+# for every row in csv file
+def croissant_transform(file_path):
+    # set output directory
+    OUTPUT_DIR = "croissant_tweet_metadata"
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    # read csv
+    df = pd.read_csv(file_path)
+
+    # columns with useful information, hard coded
+    df = df.iloc[:,0:9]
+
+    # loop
+    for index, row in df.iterrows():
+        croissant_json = Croissant_JSON_formating(row)
+        
+        # save JSON-LD file
+        file_path = os.path.join(OUTPUT_DIR, f"tweet_metadata_{index+1}.json")
+        with open(file_path, 'w') as f:
+            json.dump(croissant_json, f, indent=2)
+        print(f"{file_path} generated")
+
+    print("Conversion Finished")
+    return

src/factuality_logic.py

@@ -0,0 +1,154 @@
+# factuality_logic.py
+import os
+import re
+import json
+import logging
+import asyncio
+from pathlib import Path
+import inference_logic
+from toon_parser import parse_toon_line
+
+logger = logging.getLogger(__name__)
+
+# --- Enhanced TOON Prompts for Individual Checks ---
+# Using TOON reduces output tokens significantly compared to JSON.
+
+PROMPT_VISUAL_ARTIFACTS = (
+    "Analyze the video for visual manipulation (Deepfakes, editing anomalies).\n"
+    "Steps inside <thinking>: 1. Scan for artifacts. 2. Check cuts.\n"
+    "Output TOON format:\n"
+    "visual_analysis: result[2]{score,justification}:\n"
+    "Score(1-10),\"Justification text\""
+)
+
+PROMPT_CONTENT_ANALYSIS = (
+    "Analyze the content for accuracy and logic.\n"
+    "Steps inside <thinking>: 1. Identify claims. 2. Check fallacies. 3. Assess emotion.\n"
+    "**Transcript:**\n{transcript}\n"
+    "Output TOON format:\n"
+    "content_analysis: result[2]{score,justification}:\n"
+    "Score(1-10),\"Justification text\""
+)
+
+PROMPT_AUDIO_ANALYSIS = (
+    "Analyze audio for synthesis or manipulation.\n"
+    "Steps inside <thinking>: 1. Listen for robotic inflections. 2. Check lip-sync.\n"
+    "**Transcript:**\n{transcript}\n"
+    "Output TOON format:\n"
+    "audio_analysis: result[2]{score,justification}:\n"
+    "Score(1-10),\"Justification text\""
+)
+
+
+def parse_vtt(file_path: str) -> str:
+    """Parses a .vtt subtitle file and returns the clean text content."""
+    try:
+        if not os.path.exists(file_path):
+            return "Transcript file not found."
+        
+        with open(file_path, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+        
+        text_lines = []
+        for line in lines:
+            line = line.strip()
+            if line and not line.startswith('WEBVTT') and not '-->' in line and not line.isdigit():
+                clean_line = re.sub(r'<[^>]+>', '', line)
+                if clean_line and (not text_lines or clean_line != text_lines[-1]):
+                     text_lines.append(clean_line)
+        
+        return "\n".join(text_lines) if text_lines else "No speech found in transcript."
+    except Exception as e:
+        logger.error(f"Error parsing VTT file {file_path}: {e}")
+        return f"Error reading transcript: {e}"
+
+async def run_factuality_pipeline(paths: dict, checks: dict, generation_config: dict):
+    """
+    Asynchronously runs a pipeline of factuality checks, parses TOON scores, and yields results.
+    """
+    video_path = paths.get("video")
+    transcript_path = paths.get("transcript")
+
+    if not video_path:
+        yield "ERROR: Video path not found. Cannot start analysis.\n\n"
+        return
+
+    yield "Step 1: Processing Transcript...\n"
+    await asyncio.sleep(0.1)
+    transcript = "No transcript was downloaded for this video."
+    if transcript_path and os.path.exists(transcript_path):
+        transcript = parse_vtt(transcript_path)
+        yield f"  - Transcript file found and processed.\n"
+    else:
+        yield f"  - No transcript file was found.\n"
+    
+    yield f"\n--- Extracted Transcript ---\n{transcript}\n--------------------------\n\n"
+    await asyncio.sleep(0.1)
+
+    analysis_steps = []
+    if checks.get("visuals"):
+        analysis_steps.append(("Visual Integrity", PROMPT_VISUAL_ARTIFACTS))
+    if checks.get("content"):
+        analysis_steps.append(("Content Veracity", PROMPT_CONTENT_ANALYSIS.format(transcript=transcript)))
+    if checks.get("audio"):
+        analysis_steps.append(("Audio Forensics", PROMPT_AUDIO_ANALYSIS.format(transcript=transcript)))
+
+    for i, (title, prompt) in enumerate(analysis_steps):
+        yield f"--- Step {i + 2}: Running '{title}' Analysis ---\n"
+        yield "(Model is generating TOON analysis with scores...)\n\n"
+        await asyncio.sleep(0.1)
+
+        try:
+            current_gen_config = generation_config.copy()
+            sampling_fps = current_gen_config.pop("sampling_fps", 2.0)
+            current_gen_config.pop("num_perceptions", None)
+            
+            # FORCE LOW TEMP for structured TOON analysis
+            current_gen_config["temperature"] = 0.1 
+            current_gen_config["do_sample"] = True
+                
+            ans = inference_logic.inference_step(
+                video_path=video_path,
+                prompt=prompt,
+                generation_kwargs=current_gen_config,
+                sampling_fps=sampling_fps,
+                pred_glue=None
+            )
+
+            yield f"  - Analysis Complete for '{title}'. Parsing TOON...\n\n"
+            
+            # --- Attempt to parse TOON from the model's response ---
+            parsed_result = {}
+            # Regex to find the TOON data line: key: type[count]{headers}:\nVALUE
+            match = re.search(r'(\w+_analysis): result\[2\]\{score,justification\}:\s*\n(.+)', ans, re.MULTILINE)
+            
+            thinking = "No thinking block found."
+            think_match = re.search(r'<thinking>(.*?)</thinking>', ans, re.DOTALL)
+            if think_match:
+                thinking = think_match.group(1).strip()
+
+            if match:
+                key, value_line = match.groups()
+                parsed_result = parse_toon_line({'key': key, 'headers': ['score', 'justification']}, value_line.strip())
+            else:
+                logger.warning(f"Could not parse TOON for '{title}'. Raw: {ans}")
+                yield f"Warning: Model did not return valid TOON. Raw output:\n{ans}\n"
+                continue
+
+            # --- Display the parsed, structured result ---
+            score = parsed_result.get('score', 'N/A')
+            justification = parsed_result.get('justification', 'No justification provided.')
+            
+            yield f"===== ANALYSIS RESULT: {title.upper()} =====\n"
+            yield f"SCORE: {score}/10\n"
+            yield f"Reasoning (Step-by-Step): {thinking}\n"
+            yield f"Final Justification: {justification}\n\n"
+            yield f"========================================\n\n"
+
+        except Exception as e:
+            error_message = f"An error occurred during the '{title}' analysis step: {e}"
+            logger.error(error_message, exc_info=True)
+            yield f"ERROR: {error_message}\n\n"
+            break
+    
+    yield "Factuality Analysis Pipeline Finished.\n"

src/finetune.py

@@ -0,0 +1,165 @@
+import torch
+import os
+import logging
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from datasets import load_dataset
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+from transformers import (
+    AutoProcessor,
+    QWen3VLForConditionalGeneration,
+    TrainingArguments,
+    BitsAndBytesConfig,
+)
+from trl import SFTTrainer
+from my_vision_process import process_vision_info
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+# Configuration
+MODEL_ID = "OpenGVLab/VideoChat-R1_5"
+# This path assumes the script runs from /app via "python src/finetune.py"
+DATASET_PATH = "./data/insertlocaldataset.jsonl"
+OUTPUT_DIR = "./lora_adapters"
+
+# LoRA Configuration
+LORA_RANK = 16
+LORA_ALPHA = 32
+LORA_DROPOUT = 0.05
+TARGET_MODULES = ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+
+
+@dataclass
+class MultiModalDataCollator:
+    """A custom data collator to handle multimodal inputs (video + text) for the SFTTrainer."""
+    processor: AutoProcessor
+
+    def __call__(self, features: List[Dict[str, Any]]) -> Dict[str, Any]:
+        if len(features) != 1:
+            logger.warning(f"Data collator expected batch size 1, but got {len(features)}. Processing first item only.")
+        
+        feature = features[0]
+        video_path = feature.get("video_path")
+        text_prompt = feature.get("text")
+        
+        if not video_path or not text_prompt:
+            raise ValueError("Dataset example missing 'video_path' or 'text' field.")
+
+        # create the msg format expected by the processor
+        messages = [{"role": "user", "content": [{"type": "video", "video": video_path}, {"type": "text", "text": ""}]}]
+        
+        text_with_placeholder = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=False)
+        final_text = text_with_placeholder + text_prompt
+
+        image_inputs, video_inputs, _ = process_vision_info(messages, return_video_kwargs=True)
+        
+        model_inputs = self.processor(
+            text=[final_text],
+            images=image_inputs,
+            videos=video_inputs,
+            padding=True,
+            return_tensors="pt"
+        )
+        
+
+        model_inputs["labels"] = model_inputs["input_ids"].clone()
+        return model_inputs
+
+def print_trainable_parameters(model):
+    """Prints the number of trainable parameters in the model."""
+    trainable_params, all_param = 0, 0
+    for _, param in model.named_parameters():
+        all_param += param.numel()
+        if param.requires_grad:
+            trainable_params += param.numel()
+    logger.info(
+        f"Trainable params: {trainable_params:,} || All params: {all_param:,} || "
+        f"Trainable %: {100 * trainable_params / all_param:.2f}"
+    )
+
+def main():
+    if not os.path.exists(DATASET_PATH):
+        logger.error(f"ERROR: Dataset not found at '{DATASET_PATH}'")
+        logger.error("Please create a JSONL file with your training data. See README.md for the format.")
+        return
+
+
+    logger.info(f"Loading base model and processor from {MODEL_ID}...")
+    processor = AutoProcessor.from_pretrained(MODEL_ID)
+    
+    quantization_config = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=torch.bfloat16
+    )
+
+    model = QWen3VLForConditionalGeneration.from_pretrained(
+        MODEL_ID,
+        quantization_config=quantization_config,
+        device_map="auto",
+    )
+    model = prepare_model_for_kbit_training(model)
+
+    logger.info("configuring LoRA...")
+    lora_config = LoraConfig(
+        r=LORA_RANK,
+        lora_alpha=LORA_ALPHA,
+        lora_dropout=LORA_DROPOUT,
+        target_modules=TARGET_MODULES,
+        bias="none",
+        task_type="CAUSAL_LM",
+    )
+    model = get_peft_model(model, lora_config)
+    print_trainable_parameters(model)
+
+    logger.info(f"Loading dataset from {DATASET_PATH}...")
+    dataset = load_dataset("json", data_files=DATASET_PATH, split="train")
+
+    training_args = TrainingArguments(
+        output_dir=OUTPUT_DIR,
+        num_train_epochs=3, 
+        per_device_train_batch_size=1,
+        gradient_accumulation_steps=4,
+        learning_rate=2e-4,
+        logging_steps=5,
+        save_strategy="steps", 
+        save_steps=50,         
+        save_total_limit=3,    
+        optim="paged_adamw_8bit",
+        report_to="none",
+        bf16=True, 
+    )
+
+    # init trainer
+    trainer = SFTTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=dataset,
+        dataset_text_field="text", 
+        max_seq_length=2048,
+
+        # data_collator=MultiModalDataCollator(processor=processor), # Uncomment if needed
+    )
+
+ 
+    logger.info("fine-tuning stage")
+    
+    last_checkpoint = None
+    if os.path.isdir(training_args.output_dir):
+        potential_dirs = [os.path.join(training_args.output_dir, d) for d in os.listdir(training_args.output_dir)]
+        checkpoints = [d for d in potential_dirs if os.path.isdir(d) and os.path.basename(d).startswith("checkpoint-")]
+        if checkpoints:
+            checkpoints.sort(key=lambda x: int(os.path.basename(x).split('-')[-1]))
+            last_checkpoint = checkpoints[-1]
+            logger.info(f"Resuming training from checkpoint: {last_checkpoint}")
+
+    trainer.train(resume_from_checkpoint=last_checkpoint)
+    logger.info("Training complete.")
+
+    fin_path = os.path.join(OUTPUT_DIR, "final_checkpoint")
+    trainer.save_model(fin_path)
+    logger.info(f"final LoRA adapters saved to {fin_path}")
+
+if __name__ == "__main__":
+    main()

src/inference_logic.py

@@ -0,0 +1,377 @@
+import torch
+import re
+import ast
+import sys
+import os
+import logging
+import asyncio
+import json
+from transformers import Qwen3VLForConditionalGeneration, AutoProcessor
+from peft import PeftModel
+from my_vision_process import process_vision_info, client
+from labeling_logic import (
+    LABELING_PROMPT_TEMPLATE, SCORE_INSTRUCTIONS_SIMPLE, SCORE_INSTRUCTIONS_REASONING,
+    SCHEMA_SIMPLE, SCHEMA_REASONING,
+    FCOT_MACRO_PROMPT, FCOT_MESO_PROMPT, FCOT_SYNTHESIS_PROMPT
+)
+from toon_parser import parse_veracity_toon
+from agents import get_video_analysis_system
+
+# Google GenAI Imports
+try:
+    import google.generativeai as genai_legacy
+    from google.generativeai.types import generation_types
+except ImportError:
+    genai_legacy = None
+
+try:
+    # Modern Google GenAI SDK (v1)
+    from google import genai
+    from google.genai.types import (
+        GenerateContentConfig,
+        HttpOptions,
+        Retrieval,
+        Tool,
+        VertexAISearch,
+        GoogleSearch,
+        Part
+    )
+    import vertexai
+except ImportError:
+    genai = None
+    vertexai = None
+
+LITE_MODE = os.getenv("LITE_MODE", "false").lower() == "true"
+processor = None
+base_model = None
+peft_model = None
+active_model = None
+logger = logging.getLogger(__name__)
+
+def load_models():
+    # FIX: Declare globals at the start
+    global LITE_MODE, processor, base_model, peft_model, active_model
+    
+    if LITE_MODE:
+        logger.info("LITE_MODE is enabled. Skipping local model loading.")
+        return
+    
+    if base_model is not None: return
+    
+    if not torch.cuda.is_available():
+        # In the root container, assume GPU is needed unless forcing LITE mode logic was desired.
+        # However, to match the fix:
+        logger.warning("CUDA is not available. This application requires a GPU for local models. Switching to LITE_MODE.")
+        LITE_MODE = True
+        return
+    
+    device = torch.device("cuda")
+    logger.info(f"CUDA is available. Initializing models on {device}...")
+    local_model_path = "/app/local_model"
+    
+    try:
+        import flash_attn
+        attn_implementation = "flash_attention_2"
+    except ImportError:
+        attn_implementation = "sdpa"
+
+    logger.info(f"Loading base model from {local_model_path}...")
+    try:
+        base_model = Qwen3VLForConditionalGeneration.from_pretrained(
+            local_model_path, dtype=torch.bfloat16, device_map="auto", attn_implementation=attn_implementation
+        ).eval()
+        processor = AutoProcessor.from_pretrained(local_model_path)
+        active_model = base_model
+    except Exception as e:
+        logger.error(f"Failed to load local model: {e}")
+        LITE_MODE = True
+
+def switch_active_model(model_name: str):
+    global active_model, base_model, peft_model
+    if model_name == "custom" and peft_model is not None:
+        active_model = peft_model
+    else:
+        active_model = base_model
+
+def inference_step(video_path, prompt, generation_kwargs, sampling_fps, pred_glue=None):
+    global processor, active_model
+    if active_model is None: raise RuntimeError("Models not loaded.")
+
+    messages = [
+        {"role": "user", "content": [
+                {"type": "video", "video": video_path, 'key_time': pred_glue, 'fps': sampling_fps,
+                 "total_pixels": 128*12 * 28 * 28, "min_pixels": 128 * 28 * 28},
+                {"type": "text", "text": prompt},
+            ]
+        },
+    ]
+    text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    image_inputs, video_inputs, video_kwargs = process_vision_info(messages, return_video_kwargs=True, client=client)
+    fps_inputs = video_kwargs['fps'][0]
+    inputs = processor(text=[text], images=image_inputs, videos=video_inputs, fps=fps_inputs, padding=True, return_tensors="pt")
+    inputs = {k: v.to(active_model.device) for k, v in inputs.items()}
+
+    with torch.no_grad():
+        output_ids = active_model.generate(**inputs, **generation_kwargs, use_cache=True)
+    
+    generated_ids = [output_ids[i][len(inputs['input_ids'][i]):] for i in range(len(output_ids))]
+    output_text = processor.batch_decode(generated_ids, skip_special_tokens=True)
+    return output_text[0]
+
+async def run_inference_pipeline(video_path, question, generation_config, prompts):
+    num_perceptions = int(generation_config.pop("num_perceptions", 3))
+    sampling_fps = float(generation_config.pop("sampling_fps", 2.0))
+    if generation_config.get("temperature", 0.0) > 0.0: generation_config["do_sample"] = True
+    pred_glue = None
+    final_answer = "No answer."
+
+    for percption in range(num_perceptions):
+        yield f" Perception {percption + 1}/{num_perceptions} \n"
+        current_prompt = prompts["glue"].replace("[QUESTION]", question) if percption < num_perceptions - 1 else prompts["final"].replace("[QUESTION]", question)
+        ans = inference_step(video_path, current_prompt, generation_kwargs=generation_config, pred_glue=pred_glue, sampling_fps=sampling_fps)
+        yield f"Model Output: {ans}\n"
+        final_answer = ans
+        match_glue = re.search(r'<glue>(.*?)</glue>', ans, re.DOTALL)
+        if match_glue:
+            pred_glue = ast.literal_eval(match_glue.group(1).strip())
+        else:
+            pred_glue = None
+    yield f"\n Final Answer \n{final_answer}\n"
+
+async def attempt_toon_repair(original_text: str, schema: str, client, model_type: str, config: dict):
+    logger.info("Attempting TOON Repair via separate AI call...")
+    repair_prompt = (
+        f"SYSTEM: You are a data formatting expert. The following output from a previous model "
+        f"failed to parse correctly. \n"
+        f"YOUR TASK: Rewrite the data strictly into the following TOON schema. Do not add new content, "
+        f"just format it. If scores are missing, infer them from the text or default to 0.\n\n"
+        f"TARGET SCHEMA:\n{schema}\n\n"
+        f"BAD OUTPUT:\n{original_text}\n"
+    )
+    
+    try:
+        loop = asyncio.get_event_loop()
+        repaired_text = ""
+        
+        if model_type == 'gemini':
+            model = genai_legacy.GenerativeModel("models/gemini-2.0-flash-exp")
+            response = await loop.run_in_executor(
+                None, 
+                lambda: model.generate_content(repair_prompt, generation_config={"temperature": 0.0})
+            )
+            repaired_text = response.text
+            
+        elif model_type == 'vertex':
+            # Use separate client instance if needed or passed client
+            cl = client if client else genai.Client(vertexai=True, project=config['project_id'], location=config['location'])
+            response = await loop.run_in_executor(
+                None,
+                lambda: cl.models.generate_content(
+                    model=config['model_name'],
+                    contents=repair_prompt,
+                    config=GenerateContentConfig(temperature=0.0)
+                )
+            )
+            repaired_text = response.text
+            
+        logger.info(f"Repair successful. New text length: {len(repaired_text)}")
+        return repaired_text
+    except Exception as e:
+        logger.error(f"Repair failed: {e}")
+        return original_text
+
+async def run_gemini_labeling_pipeline(video_path: str, caption: str, transcript: str, gemini_config: dict, include_comments: bool, reasoning_method: str = "cot"):
+    if genai_legacy is None:
+        yield "ERROR: Legacy SDK missing.\n"
+        return
+    
+    api_key = gemini_config.get("api_key")
+    if not api_key: return
+    
+    try:
+        genai_legacy.configure(api_key=api_key)
+        loop = asyncio.get_event_loop()
+        uploaded_file = await loop.run_in_executor(None, lambda: genai_legacy.upload_file(path=video_path))
+        while uploaded_file.state.name == "PROCESSING": await asyncio.sleep(2)
+        
+        model = genai_legacy.GenerativeModel("models/gemini-2.0-flash-exp")
+        toon_schema = SCHEMA_REASONING if include_comments else SCHEMA_SIMPLE
+        score_instructions = SCORE_INSTRUCTIONS_REASONING if include_comments else SCORE_INSTRUCTIONS_SIMPLE
+        
+        raw_text = ""
+        prompt_used = ""
+
+        if reasoning_method == "fcot":
+            # ... existing fcot logic ...
+            pass
+        elif reasoning_method == "agentic":
+            yield "Starting Multi-Agent Analysis..."
+            # Create a clean system instance with the provided API key
+            model_name = gemini_config.get("model_name", "models/gemini-2.1-flash-lite")
+            system = get_video_analysis_system(api_key=api_key, model_name=model_name)
+            
+            results = await loop.run_in_executor(None, lambda: system.run(
+                video_path=video_path,
+                caption=caption,
+                transcript=transcript
+            ))
+            # Concatenate agent outputs for parsing
+            raw_text = "\n\n".join([str(res) for res in results])
+            prompt_used = "Multi-Agent System Execution"
+        else:
+            # --- Standard Chain of Thought (Single Turn) ---
+            prompt_text = LABELING_PROMPT_TEMPLATE.format(
+                caption=caption, 
+                transcript=transcript,
+                toon_schema=toon_schema,
+                score_instructions=score_instructions
+            )
+            prompt_used = prompt_text
+            yield "Generating Labels (Standard CoT)..."
+            response = await loop.run_in_executor(None, lambda: model.generate_content([prompt_text, uploaded_file], generation_config={"temperature": 0.1}))
+            raw_text = response.text
+        
+        if not raw_text:
+             yield "Model returned empty response (possibly triggered safety filter)."
+             yield {"error": "Empty Response"}
+             return
+
+        parsed_data = parse_veracity_toon(raw_text)
+        
+        is_zero = parsed_data['veracity_vectors']['visual_integrity_score'] == '0'
+        if is_zero:
+             yield "Parsing incomplete (score 0). Initiating Auto-Repair..."
+             raw_text = await attempt_toon_repair(raw_text, toon_schema, None, 'gemini', gemini_config)
+             parsed_data = parse_veracity_toon(raw_text)
+
+        yield {"raw_toon": raw_text, "parsed_data": parsed_data, "prompt_used": prompt_used}
+        await loop.run_in_executor(None, lambda: genai_legacy.delete_file(name=uploaded_file.name))
+
+    except Exception as e:
+        yield f"ERROR: {e}"
+
+async def run_vertex_labeling_pipeline(video_path: str, caption: str, transcript: str, vertex_config: dict, include_comments: bool, reasoning_method: str = "cot"):
+    if genai is None:
+        yield "ERROR: 'google-genai' not installed.\n"
+        return
+
+    project_id = vertex_config.get("project_id")
+    location = vertex_config.get("location", "us-central1")
+    model_name = vertex_config.get("model_name", "gemini-1.5-pro-preview-0409")
+    
+    if not project_id: return
+
+    try:
+        client = genai.Client(vertexai=True, project=project_id, location=location)
+        with open(video_path, 'rb') as f:
+            video_bytes = f.read()
+        video_part = Part.from_bytes(data=video_bytes, mime_type="video/mp4")
+
+        toon_schema = SCHEMA_REASONING if include_comments else SCHEMA_SIMPLE
+        score_instructions = SCORE_INSTRUCTIONS_REASONING if include_comments else SCORE_INSTRUCTIONS_SIMPLE
+        
+        raw_text = ""
+        prompt_used = ""
+        
+        loop = asyncio.get_event_loop()
+        config = GenerateContentConfig(
+            temperature=0.1,
+            response_mime_type="text/plain",
+            max_output_tokens=8192,
+            tools=[Tool(google_search=GoogleSearch())]
+        )
+
+        if reasoning_method == "fcot":
+            # --- Fractal Chain of Thought (Vertex) ---
+            yield "Starting Fractal Chain of Thought (Vertex FCoT)..."
+            chat = client.chats.create(model=model_name, config=config)
+            
+            # 1. Macro
+            yield "FCoT Step 1: Macro-Scale..."
+            macro_prompt = FCOT_MACRO_PROMPT.format(caption=caption, transcript=transcript)
+            # First message must contain the video
+            res1 = await loop.run_in_executor(None, lambda: chat.send_message([video_part, macro_prompt]))
+            macro_hypothesis = res1.text
+            yield f"Hypothesis: {macro_hypothesis[:80]}...\n"
+
+            # 2. Meso
+            yield "FCoT Step 2: Meso-Scale..."
+            meso_prompt = FCOT_MESO_PROMPT.format(macro_hypothesis=macro_hypothesis)
+            res2 = await loop.run_in_executor(None, lambda: chat.send_message(meso_prompt))
+            
+            # 3. Synthesis
+            yield "FCoT Step 3: Synthesis..."
+            synthesis_prompt = FCOT_SYNTHESIS_PROMPT.format(toon_schema=toon_schema, score_instructions=score_instructions)
+            res3 = await loop.run_in_executor(None, lambda: chat.send_message(synthesis_prompt))
+            
+            raw_text = res3.text
+            prompt_used = f"FCoT (Vertex):\nMacro: {macro_prompt}\nMeso: {meso_prompt}\nSynthesis: {synthesis_prompt}"
+
+        else:
+            # --- Standard CoT ---
+            prompt_text = LABELING_PROMPT_TEMPLATE.format(
+                caption=caption, 
+                transcript=transcript,
+                toon_schema=toon_schema,
+                score_instructions=score_instructions
+            )
+            prompt_used = prompt_text
+            yield "Generating Labels (Vertex CoT)..."
+            
+            response = await loop.run_in_executor(
+                None, 
+                lambda: client.models.generate_content(
+                    model=model_name,
+                    contents=[video_part, prompt_text],
+                    config=config
+                )
+            )
+            raw_text = response.text
+        
+        if not raw_text:
+             yield "Model returned empty response."
+             yield {"error": "Empty Response"}
+             return
+
+        parsed_data = parse_veracity_toon(raw_text)
+        
+        is_zero = parsed_data['veracity_vectors']['visual_integrity_score'] == '0'
+        if is_zero:
+            yield "Parsing incomplete (score 0). Initiating Auto-Repair..."
+            raw_text = await attempt_toon_repair(raw_text, toon_schema, client, 'vertex', vertex_config)
+            parsed_data = parse_veracity_toon(raw_text)
+
+        yield {"raw_toon": raw_text, "parsed_data": parsed_data, "prompt_used": prompt_used}
+            
+    except Exception as e:
+        yield f"ERROR: {e}"
+        logger.error("Vertex Labeling Error", exc_info=True)
+
+# Keep legacy pipeline functions for general Q&A compatibility
+async def run_gemini_pipeline(video_path, question, checks, gemini_config, generation_config=None):
+    if genai_legacy is None: return
+    api_key = gemini_config.get("api_key")
+    if not api_key: return
+    genai_legacy.configure(api_key=api_key)
+    loop = asyncio.get_event_loop()
+    uploaded_file = await loop.run_in_executor(None, lambda: genai_legacy.upload_file(path=video_path))
+    while uploaded_file.state.name == "PROCESSING": await asyncio.sleep(2)
+    model = genai_legacy.GenerativeModel(gemini_config.get("model_name", "models/gemini-1.5-pro-latest"))
+    response = await loop.run_in_executor(None, lambda: model.generate_content([question, uploaded_file]))
+    yield response.text
+    await loop.run_in_executor(None, lambda: genai_legacy.delete_file(name=uploaded_file.name))
+
+async def run_vertex_pipeline(video_path, question, checks, vertex_config, generation_config=None):
+    if genai is None: return
+    client = genai.Client(vertexai=True, project=vertex_config['project_id'], location=vertex_config['location'])
+    with open(video_path, 'rb') as f: video_bytes = f.read()
+    video_part = Part.from_bytes(data=video_bytes, mime_type="video/mp4")
+    loop = asyncio.get_event_loop()
+    response = await loop.run_in_executor(
+        None,
+        lambda: client.models.generate_content(
+            model=vertex_config.get("model_name", "gemini-2.5-flash-lite"),
+            contents=[video_part, question]
+        )
+    )
+    yield response.text

src/labeling_logic.py

@@ -0,0 +1,158 @@
+# Utilizes TOON (Token-Oriented Object Notation) for token efficiency and structured output.
+
+LABELING_PROMPT_TEMPLATE = """
+You are an AI Factuality Assessment Agent operating under the "Ali Arsanjani Factuality Factors" framework. 
+Your goal is to mass-label video content, quantifying "Veracity Vectors" and "Modality Alignment".
+
+**INPUT DATA:**
+- **User Caption:** "{caption}"
+- **Audio Transcript:** "{transcript}"
+- **Visuals:** (Provided in video context)
+
+**INSTRUCTIONS:**
+1.  **Grounding:** Cross-reference claims in the transcript with your internal knowledge base (and tools if active).
+2.  **Chain of Thought (<thinking>):** You MUST think step-by-step inside a `<thinking>` block before generating output.
+    *   Analyze *Visual Integrity* (Artifacts, edits).
+    *   Analyze *Audio Integrity* (Voice cloning, sync).
+    *   Analyze *Modality Alignment* (Does video match audio? Does caption match content? Does audio match caption?).
+    *   Analyze *Logic* (Fallacies, gaps).
+    *   **Classify Tags:** Identify 3-5 relevant tags (e.g., "political", "celebrity", "targeting", "satire", "news").
+    *   Determine *Disinformation* classification.
+3.  **Output Format:** Output strictly in **TOON** format (Token-Oriented Object Notation) as defined below.
+
+**CRITICAL CONSTRAINTS:** 
+- Do NOT repeat the input data.
+- START your response IMMEDIATELY with the `<thinking>` tag.
+- **DO NOT use Markdown code blocks.** (Output plain text only).
+- Use strict `Key : Type [ Count ] {{ Headers }} :` format followed by data lines.
+- Strings containing commas MUST be quoted.
+- ALL scores must be filled (use 0 if unsure, do not leave blank).
+- **MODALITY SCORING:** You must provide 3 distinct alignment scores: Video-Audio, Video-Caption, and Audio-Caption.
+
+**TOON SCHEMA:**
+{toon_schema}
+
+{score_instructions}
+
+**RESPONSE:**
+<thinking>
+"""
+
+SCORE_INSTRUCTIONS_REASONING = """
+**Constraints:** 
+1. Provide specific reasoning for EACH score in the `vectors` and `modalities` tables.
+2. Ensure strings are properly quoted.
+"""
+
+SCORE_INSTRUCTIONS_SIMPLE = """
+**Constraint:** Focus on objective measurements. Keep text concise.
+"""
+
+# Updated Schema based on user requirements - Ensure explicit newlines
+SCHEMA_SIMPLE = """summary: text[1]{text}:
+"Brief neutral summary of the video events"
+
+tags: list[1]{keywords}:
+"political, celebrity, deepfake, viral"
+
+vectors: scores[1]{visual,audio,source,logic,emotion}:
+(Int 1-10),(Int 1-10),(Int 1-10),(Int 1-10),(Int 1-10)
+*Scale: 1=Fake/Malicious, 10=Authentic/Neutral*
+
+modalities: scores[1]{video_audio_score,video_caption_score,audio_caption_score}:
+(Int 1-10),(Int 1-10),(Int 1-10)
+*Scale: 1=Mismatch, 10=Perfect Match*
+
+factuality: factors[1]{accuracy,gap,grounding}:
+(Verified/Misleading/False),"Missing evidence description","Grounding check results"
+
+disinfo: analysis[1]{class,intent,threat}:
+(None/Misinfo/Disinfo/Satire),(Political/Commercial/None),(Deepfake/Recontextualization/None)
+
+final: assessment[1]{score,reasoning}:
+(Int 1-100),"Final synthesis of why this score was given"
+"""
+
+SCHEMA_REASONING = """
+summary: text[1]{text}:
+"Brief neutral summary of the video events"
+
+tags: list[1]{keywords}:
+"political, celebrity, deepfake, viral"
+
+vectors: details[5]{category,score,reasoning}:
+Visual,(Int 1-10),"Reasoning for visual score"
+Audio,(Int 1-10),"Reasoning for audio score"
+Source,(Int 1-10),"Reasoning for source credibility"
+Logic,(Int 1-10),"Reasoning for logical consistency"
+Emotion,(Int 1-10),"Reasoning for emotional manipulation"
+
+modalities: details[3]{category,score,reasoning}:
+VideoAudio,(Int 1-10),"Reasoning for video-to-audio alignment"
+VideoCaption,(Int 1-10),"Reasoning for video-to-caption alignment"
+AudioCaption,(Int 1-10),"Reasoning for audio-to-caption alignment"
+
+factuality: factors[1]{accuracy,gap,grounding}:
+(Verified/Misleading/False),"Missing evidence description","Grounding check results"
+
+disinfo: analysis[1]{class,intent,threat}:
+(None/Misinfo/Disinfo/Satire),(Political/Commercial/None),(Deepfake/Recontextualization/None)
+
+final: assessment[1]{score,reasoning}:
+(Int 1-100),"Final synthesis of why this score was given"
+"""
+
+# ==========================================
+# Fractal Chain of Thought (FCoT) Prompts
+# ==========================================
+
+FCOT_MACRO_PROMPT = """
+**Fractal Chain of Thought - Stage 1: Macro-Scale Hypothesis (Wide Aperture)**
+
+You are analyzing a video for factuality.
+**Context:** Caption: "{caption}" | Transcript: "{transcript}"
+
+1. **Global Scan**: Observe the video, audio, and caption as a whole entity.
+2. **Context Aperture**: Wide. Assess the overall intent (Humor, Information, Political, Social) and the setting.
+3. **Macro Hypothesis**: Formulate a high-level hypothesis about the veracity. (e.g., "The video is likely authentic but the caption misrepresents the location" or "The audio quality suggests synthetic generation").
+
+**Objective**: Maximize **Coverage** (broadly explore potential angles of manipulation).
+
+**Output**: A concise paragraph summarizing the "Macro Hypothesis".
+"""
+
+FCOT_MESO_PROMPT = """
+**Fractal Chain of Thought - Stage 2: Meso-Scale Expansion (Recursive Verification)**
+
+**Current Macro Hypothesis**: "{macro_hypothesis}"
+
+**Action**: Zoom In. Decompose the hypothesis into specific verification branches.
+Perform the following checks recursively:
+
+1. **Visual Branch**: Look for specific artifacts, lighting inconsistencies, cuts, or deepfake signs.
+2. **Audio Branch**: Analyze lip-sync, background noise consistency, and voice tonality.
+3. **Logical Branch**: Does the visual evidence strictly support the caption's claim? Are there logical fallacies?
+
+**Dual-Objective Self-Correction**:
+- **Faithfulness**: Do not hallucinate details not present in the video.
+- **Coverage**: Did you miss any subtle cues?
+
+**Output**: Detailed "Micro-Observations" for each branch. If you find contradictions to the Macro Hypothesis, note them explicitly as **"Self-Correction"**.
+"""
+
+FCOT_SYNTHESIS_PROMPT = """
+**Fractal Chain of Thought - Stage 3: Inter-Scale Consensus & Synthesis**
+
+**Action**: Integrate your Macro Hypothesis and Micro-Observations.
+- **Consensus Check**: If Micro-Observations contradict the Macro Hypothesis, prioritize the Micro evidence (Self-Correction).
+- **Compression**: Synthesize the findings into the final structured format.
+- **Tags**: Assign 3-5 high-level tags (e.g., "political", "fabricated", "humor").
+
+**Output Format**:
+Strictly fill out the following TOON schema based on the consensus. Do not include markdown code blocks.
+
+**TOON SCHEMA**:
+{toon_schema}
+
+{score_instructions}
+"""

src/model.py

@@ -0,0 +1,93 @@
+from transformers import Qwen3VLForConditionalGeneration, AutoProcessor
+from my_vision_process import process_vision_info
+import torch
+import re
+import ast
+
+# Note: The model class has been updated to Qwen3VLForConditionalGeneration for consistency
+# with the main application and the latest transformers library conventions for this model.
+model_path = "OpenGVLab/VideoChat-R1_5"
+# default: Load the model on the available device(s)
+model = Qwen3VLForConditionalGeneration.from_pretrained(
+    model_path, torch_dtype="auto", device_map="auto",
+    attn_implementation="flash_attention_2"
+).eval()
+
+# default processer
+processor = AutoProcessor.from_pretrained(model_path)
+
+video_path = "your_video.mp4"
+question = "your_qa.mp4"
+num_percptions = 3
+
+QA_THINK_GLUE = """Answer the question: "[QUESTION]" according to the content of the video. 
+
+Output your think process within the  <think> </think> tags.
+
+Then, provide your answer within the <answer> </answer> tags, output the corresponding letter of the option. At the same time, in the <glue> </glue> tags, present the precise time period in seconds of the video clips on which you base your answer to this question in the format of [(s1, e1), (s2, e2), ...]. For example: <think>...</think><answer>A</answer><glue>[(5.2, 10.4)]</glue>.
+"""
+
+QA_THINK = """Answer the question: "[QUESTION]" according to the content of the video.
+
+Output your think process within the  <think> </think> tags.
+
+Then, provide your answer within the <answer> </answer> tags, output the corresponding letter of the option. For example: <think>...</think><answer>A</answer><glue>[(5.2, 10.4)]</glue>.
+"""
+
+
+def inference(video_path, prompt, model, processor, max_new_tokens=2048, client=None, pred_glue=None):
+    device = model.device
+    messages = [
+        {"role": "user", "content": [
+                {"type": "video", 
+                "video": video_path,
+                'key_time':pred_glue,
+                "total_pixels": 128*12 * 28 * 28, 
+                "min_pixels": 128 * 28 * 28,
+                },
+                {"type": "text", "text": prompt},
+            ]
+        },
+    ]
+    text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+
+    image_inputs, video_inputs, video_kwargs = process_vision_info(messages, return_video_kwargs=True, client=client)
+    fps_inputs = video_kwargs['fps'][0]
+
+    inputs = processor(text=[text], images=image_inputs, videos=video_inputs, fps=fps_inputs, padding=True, return_tensors="pt")
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+
+    with torch.no_grad():
+        output_ids = model.generate(**inputs, max_new_tokens=max_new_tokens, use_cache=True)
+
+    generated_ids = [output_ids[i][len(inputs['input_ids'][i]):] for i in range(len(output_ids))]
+    output_text = processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+    return output_text[0]
+
+
+# This is example usage code. You should replace the placeholders.
+# For example:
+# item = {"problem": {"question": "What is the person doing in the video?"}}
+# client = None # Or initialize your client
+# pred_glue = None
+# answers = []
+
+# for percption in range(num_percptions):    
+#     if percption == num_percptions - 1:
+#         example_prompt = QA_THINK.replace("[QUESTION]", item["problem"]["question"])
+#     else:
+#         example_prompt = QA_THINK_GLUE.replace("[QUESTION]", item["problem"]["question"])
+
+#     ans = inference(video_path, example_prompt, model, processor, client=client, pred_glue=pred_glue)
+
+#     pattern_glue = r'<glue>(.*?)</glue>'
+#     match_glue = re.search(pattern_glue, ans, re.DOTALL)
+#     answers.append(ans)
+#     pred_glue = None
+#     try:
+#         if match_glue:
+#             glue = match_glue.group(1)
+#             pred_glue = ast.literal_eval(glue)
+#     except Exception as e:
+#         pred_glue = None
+# print(ans)

src/my_vision_process.py

@@ -0,0 +1,812 @@
+from __future__ import annotations
+
+from torchvision import transforms
+import base64
+import logging
+import math
+import os
+import sys
+import time
+import warnings
+from functools import lru_cache
+from io import BytesIO
+
+import requests
+import torch
+import torchvision
+from packaging import version
+from PIL import Image
+from torchvision import io, transforms
+from torchvision.transforms import InterpolationMode
+from typing import Optional
+import random
+import os
+import io
+import av
+import cv2
+import decord
+import imageio
+from decord import VideoReader
+import torch
+import numpy as np
+import math
+import gc
+import torchaudio
+from torchvision.transforms.functional import pil_to_tensor
+import re
+logger = logging.getLogger(__name__)
+
+# from models.backbones.beats.BEATs import BEATs, BEATsConfig
+try:
+    from petrel_client.client import Client
+    client = Client('~/petreloss.conf')
+except (ImportError, FileNotFoundError):
+    # This is expected if petrel is not used.
+    client = None
+
+
+def get_index(num_frames, num_segments):
+    seg_size = float(num_frames - 1) / num_segments
+    start = int(seg_size / 2)
+    offsets = np.array([
+        start + int(np.round(seg_size * idx)) for idx in range(num_segments)
+    ])
+    return offsets
+
+def get_frame_indices(num_frames, vlen, sample='middle', fix_start=None, input_fps=1, min_num_frames=1, max_num_frames=-1, local_num_frames=8):
+
+    if min_num_frames > vlen:
+        if sample == 'dynamic_fps1':
+            min_num_frames = (vlen // local_num_frames) * local_num_frames
+        else:
+            min_num_frames = vlen
+
+
+    if sample == 'dynamic_fps1':
+
+        duration = float(vlen) / input_fps
+        num_segments = int(duration // local_num_frames)
+        if num_segments == 0:
+            num_frames = local_num_frames
+        else:
+            num_frames = local_num_frames * num_segments
+
+        if max_num_frames > 0:
+            num_frames = min(num_frames, max_num_frames)
+        sample = "middle" # NOTE
+
+        # logger.info(f"? is OK (img), duation={duration} frames={num_frames}!!!!")
+
+    num_frames = max(min_num_frames, num_frames)
+
+    # print(f"\033[0;31m vlen={vlen}, input_fps={input_fps} num_frames={num_frames} \033[0m")
+        
+    if sample in ["rand", "middle"]: # uniform sampling
+        acc_samples = min(num_frames, vlen)
+        # split the video into `acc_samples` intervals, and sample from each interval.
+        intervals = np.linspace(start=0, stop=vlen, num=acc_samples + 1).astype(int)
+        ranges = []
+        for idx, interv in enumerate(intervals[:-1]):
+            ranges.append((interv, intervals[idx + 1] - 1))
+        if sample == 'rand':
+            try:
+                frame_indices = [random.choice(range(x[0], x[1])) for x in ranges]
+            except:
+                frame_indices = np.random.permutation(vlen)[:acc_samples]
+                frame_indices.sort()
+                frame_indices = list(frame_indices)
+        elif fix_start is not None:
+            frame_indices = [x[0] + fix_start for x in ranges]
+        elif sample == 'middle':
+            frame_indices = [(x[0] + x[1]) // 2 for x in ranges]
+        else:
+            raise NotImplementedError
+
+        if len(frame_indices) < num_frames:  # padded with last frame
+            padded_frame_indices = [frame_indices[-1]] * num_frames
+            padded_frame_indices[:len(frame_indices)] = frame_indices
+            frame_indices = padded_frame_indices
+    elif "fps" in sample:  # fps0.5, sequentially sample frames at 0.5 fps
+        raise NotImplementedError
+        output_fps = float(sample[3:])
+        duration = float(vlen) / input_fps
+        delta = 1 / output_fps  # gap between frames, this is also the clip length each frame represents
+        frame_seconds = np.arange(0 + delta / 2, duration + delta / 2, delta)
+        frame_indices = np.around(frame_seconds * input_fps).astype(int)
+        frame_indices = [e for e in frame_indices if e < vlen]
+        if max_num_frames > 0 and len(frame_indices) > max_num_frames:
+            frame_indices = frame_indices[:max_num_frames]
+            # frame_indices = np.linspace(0 + delta / 2, duration + delta / 2, endpoint=False, num=max_num_frames)
+    else:
+        raise ValueError(f"Not support sample type: {sample}")
+    
+    
+    return frame_indices
+
+
+
+logger = logging.getLogger(__name__)
+
+IMAGE_FACTOR = 28
+MIN_PIXELS = 4 * 28 * 28
+MAX_PIXELS = 768 * 28 * 28
+MAX_RATIO = 200
+
+VIDEO_MIN_PIXELS = 128 * 28 * 28
+VIDEO_MAX_PIXELS = 768 * 28 * 28
+FRAME_FACTOR = 2
+FPS = 2.0
+FPS_MIN_FRAMES = 4
+FPS_MAX_FRAMES = 512
+
+# Set the maximum number of video token inputs.
+# Here, 128K represents the maximum number of input tokens for the VLLM model.
+# Remember to adjust it according to your own configuration.
+VIDEO_TOTAL_PIXELS = int(float(os.environ.get('VIDEO_MAX_PIXELS', 128000 * 28 * 28 * 0.9)))
+# logger.info(f"set VIDEO_TOTAL_PIXELS: {VIDEO_TOTAL_PIXELS}")
+
+
+def round_by_factor(number: int, factor: int) -> int:
+    """Returns the closest integer to 'number' that is divisible by 'factor'."""
+    return round(number / factor) * factor
+
+
+def ceil_by_factor(number: int, factor: int) -> int:
+    """Returns the smallest integer greater than or equal to 'number' that is divisible by 'factor'."""
+    return math.ceil(number / factor) * factor
+
+
+def floor_by_factor(number: int, factor: int) -> int:
+    """Returns the largest integer less than or equal to 'number' that is divisible by 'factor'."""
+    return math.floor(number / factor) * factor
+
+
+def smart_resize(
+    height: int, width: int, factor: int = IMAGE_FACTOR, min_pixels: int = MIN_PIXELS, max_pixels: int = MAX_PIXELS
+) -> tuple[int, int]:
+    """
+    Rescales the image so that the following conditions are met:
+
+    1. Both dimensions (height and width) are divisible by 'factor'.
+
+    2. The total number of pixels is within the range ['min_pixels', 'max_pixels'].
+
+    3. The aspect ratio of the image is maintained as closely as possible.
+    """
+    if min(height, width) == 0:
+        return 0, 0
+    if max(height, width) / min(height, width) > MAX_RATIO:
+        raise ValueError(
+            f"absolute aspect ratio must be smaller than {MAX_RATIO}, got {max(height, width) / min(height, width)}"
+        )
+    h_bar = max(factor, round_by_factor(height, factor))
+    w_bar = max(factor, round_by_factor(width, factor))
+    if h_bar * w_bar > max_pixels:
+        beta = math.sqrt((height * width) / max_pixels)
+        h_bar = floor_by_factor(height / beta, factor)
+        w_bar = floor_by_factor(width / beta, factor)
+    elif h_bar * w_bar < min_pixels:
+        beta = math.sqrt(min_pixels / (height * width))
+        h_bar = ceil_by_factor(height * beta, factor)
+        w_bar = ceil_by_factor(width * beta, factor)
+    return h_bar, w_bar
+
+
+def to_rgb(pil_image: Image.Image) -> Image.Image:
+      if pil_image.mode == 'RGBA':
+          white_background = Image.new("RGB", pil_image.size, (255, 255, 255))
+          white_background.paste(pil_image, mask=pil_image.split()[3])  # Use alpha channel as mask
+          return white_background
+      else:
+          return pil_image.convert("RGB")
+
+
+def fetch_image(ele: dict[str, str | Image.Image], client= None, size_factor: int = IMAGE_FACTOR) -> Image.Image:
+    if "image" in ele:
+        image = ele["image"]
+    else:
+        image = ele["image_url"]
+    image_obj = None
+    if isinstance(image, Image.Image):
+        image_obj = image
+    elif isinstance(image, list) and isinstance(image[0], Image.Image):
+        image_obj = image[0]
+    elif image.startswith("http://") or image.startswith("https://"):
+        response = requests.get(image, stream=True)
+        image_obj = Image.open(BytesIO(response.content))
+    elif image.startswith("file://"):
+        image_obj = Image.open(image[7:])
+    elif image.startswith("data:image"):
+        if "base64," in image:
+            _, base64_data = image.split("base64,", 1)
+            data = base64.b64decode(base64_data)
+            image_obj = Image.open(BytesIO(data))
+    elif 's3' in image and client is not None:
+        file_content = client.get(image)
+        image_obj = Image.open(io.BytesIO(file_content))
+    else:
+        image_obj = Image.open(image)
+    if image_obj is None:
+        raise ValueError(f"Unrecognized image input, support local path, http url, base64 and PIL.Image, got {image}")
+    image = to_rgb(image_obj)
+    ## resize
+    if "resized_height" in ele and "resized_width" in ele:
+        resized_height, resized_width = smart_resize(
+            ele["resized_height"],
+            ele["resized_width"],
+            factor=size_factor,
+        )
+    else:
+        width, height = image.size
+        min_pixels = ele.get("min_pixels", MIN_PIXELS)
+        max_pixels = ele.get("max_pixels", MAX_PIXELS)
+        resized_height, resized_width = smart_resize(
+            height,
+            width,
+            factor=size_factor,
+            min_pixels=min_pixels,
+            max_pixels=max_pixels,
+        )
+    image = image.resize((resized_width, resized_height))
+
+    return image
+
+
+def smart_nframes(
+    ele: dict,
+    total_frames: int,
+    video_fps: int | float,
+) -> int:
+    """calculate the number of frames for video used for model inputs.
+
+    Args:
+        ele (dict): a dict contains the configuration of video.
+            support either `fps` or `nframes`:
+                - nframes: the number of frames to extract for model inputs.
+                - fps: the fps to extract frames for model inputs.
+                    - min_frames: the minimum number of frames of the video, only used when fps is provided.
+                    - max_frames: the maximum number of frames of the video, only used when fps is provided.
+        total_frames (int): the original total number of frames of the video.
+        video_fps (int | float): the original fps of the video.
+
+    Raises:
+        ValueError: nframes should in interval [FRAME_FACTOR, total_frames].
+
+    Returns:
+        int: the number of frames for video used for model inputs.
+    """
+    assert not ("fps" in ele and "nframes" in ele), "Only accept either `fps` or `nframes`"
+    if "nframes" in ele:
+        nframes = round_by_factor(ele["nframes"], FRAME_FACTOR)
+    else:
+        fps = ele.get("fps", FPS)
+        min_frames = ceil_by_factor(ele.get("min_frames", FPS_MIN_FRAMES), FRAME_FACTOR)
+        max_frames = floor_by_factor(ele.get("max_frames", min(FPS_MAX_FRAMES, total_frames)), FRAME_FACTOR)
+        if video_fps > 0:
+            nframes = total_frames / video_fps * fps
+        else: # if video_fps is 0, use total_frames as nframes
+            nframes = total_frames
+        if nframes > total_frames:
+            logger.warning(f"smart_nframes: nframes[{nframes}] > total_frames[{total_frames}]")
+        nframes = min(min(max(nframes, min_frames), max_frames), total_frames)
+        nframes = floor_by_factor(nframes, FRAME_FACTOR)
+    if not (FRAME_FACTOR <= nframes and nframes <= total_frames) and total_frames > FRAME_FACTOR:
+        logger.warning(f"nframes should in interval [{FRAME_FACTOR}, {total_frames}], but got {nframes}.")
+        nframes = max(FRAME_FACTOR, min(nframes, total_frames))
+    return nframes
+
+
+def _read_video_torchvision(
+    ele: dict,
+) -> (torch.Tensor, float):
+    raise NotImplementedError("Torchvision reader is not fully supported in this context.")
+    """read video using torchvision.io.read_video
+
+    Args:
+        ele (dict): a dict contains the configuration of video.
+        support keys:
+            - video: the path of video. support "file://", "http://", "https://" and local path.
+            - video_start: the start time of video.
+            - video_end: the end time of video.
+    Returns:
+        torch.Tensor: the video tensor with shape (T, C, H, W).
+    """
+    video_path = ele["video"]
+    if version.parse(torchvision.__version__) < version.parse("0.19.0"):
+        if "http://" in video_path or "https://" in video_path:
+            warnings.warn("torchvision < 0.19.0 does not support http/https video path, please upgrade to 0.19.0.")
+        if "file://" in video_path:
+            video_path = video_path[7:]
+    st = time.time()
+    video, audio, info = io.read_video(
+        video_path,
+        start_pts=ele.get("video_start", 0.0),
+        end_pts=ele.get("video_end", None),
+        pts_unit="sec",
+        output_format="TCHW",
+    )
+    total_frames, video_fps = video.size(0), info["video_fps"]
+    logger.info(f"torchvision:  {video_path=}, {total_frames=}, {video_fps=}, time={time.time() - st:.3f}s")
+    nframes = smart_nframes(ele, total_frames=total_frames, video_fps=video_fps)
+    idx = torch.linspace(0, total_frames - 1, nframes).round().long()
+    sample_fps = nframes / max(total_frames, 1e-6) * video_fps
+    video = video[idx]
+    return video, sample_fps
+
+
+def is_decord_available() -> bool:
+    import importlib.util
+
+    return importlib.util.find_spec("decord") is not None
+
+def pts_to_secs(pts: int, time_base: float, start_pts: int) -> float:
+    """
+    Converts a present time with the given time base and start_pts offset to seconds.
+
+    Returns:
+        time_in_seconds (float): The corresponding time in seconds.
+
+    https://github.com/facebookresearch/pytorchvideo/blob/main/pytorchvideo/data/utils.py#L54-L64
+    """
+    if pts == math.inf:
+        return math.inf
+
+    return int(pts - start_pts) * time_base
+
+def get_pyav_video_duration(video_reader):
+    video_stream = video_reader.streams.video[0]
+    video_duration = pts_to_secs(
+        video_stream.duration,
+        video_stream.time_base,
+        video_stream.start_time
+    )
+    return float(video_duration)
+
+
+
+def _read_video_img(
+    ele: dict,
+    client
+) -> (torch.Tensor, float):
+    """read video using decord.VideoReader
+
+    Args:
+        ele (dict): a dict contains the configuration of video.
+        support keys:
+            - video: the path of video. support "file://", "http://", "https://" and local path.
+            - video_start: the start time of video.
+            - video_end: the end time of video.
+    Returns:
+        torch.Tensor: the video tensor with shape (T, C, H, W).
+    """
+    import re
+
+    def extract_frame_number(filename):
+        # Extract the numeric part from the filename using regular expressions
+        if filename.endswith('.jpg'):
+            match = re.search(r'_(\d+).jpg$', filename)
+        elif filename.endswith('.jpeg'):
+            match = re.search(r'_(\d+).jpeg$', filename)
+        elif filename.endswith('.png'):
+            match = re.search(r'_(\d+).png$', filename)
+        else:
+            raise NotImplementedError(f"Wrong filename: {filename}")
+
+        return int(match.group(1)) if match else -1
+
+
+    def sort_frames(frame_paths):
+        # Extract filenames from each path and sort by their numeric part
+        return sorted(frame_paths, key=lambda x: extract_frame_number(os.path.basename(x)))
+    video_path = ele["video"]
+    # import pdb; pdb.set_trace()
+    if 'media_dict' in ele:
+        media_dict = ele["media_dict"]
+    else:
+        media_dict = {}
+    if "s3://" in video_path and client is not None:
+        img_list = sort_frames(client.list(video_path))
+    else:
+        img_list = sort_frames(list(os.listdir(video_path)))
+    
+    
+    
+    if "start" in media_dict.keys():
+        clip = [media_dict['start'], media_dict['end']]
+    else:
+        clip = None
+
+    if 'tvqa' in video_path.lower():
+        fps = 3.0 # TVQA is 3fps
+    else:
+        fps = 1.0 # NOTE: Treat unknown data as 1fps by default
+
+    if clip is not None:
+        start = float(clip[0])
+        end = float(clip[1])
+        start = max(0, start)
+        end = min(len(img_list) / fps, end) # prevent end from exceeding video end 
+        vlen = (end - start) * fps
+    else:
+        vlen = len(img_list)
+    
+    duration = vlen / fps
+
+    num_frames = smart_nframes(ele, total_frames=vlen, video_fps=fps)
+    sample = 'middle'
+    if clip is not None:
+        def _get_index_by_time(start_sec, end_sec, num_segments=8, fps=1., max_frame=9999):
+            start_idx = max(1, round(start_sec * fps))
+            end_idx = min(round(end_sec * fps), max_frame)
+            seg_size = float(end_idx - start_idx) / (num_segments - 1)
+            offsets = np.array([start_idx + int(np.round(seg_size * idx)) for idx in range(num_segments)])
+            return offsets
+
+        frame_indices = _get_index_by_time(float(clip[0]), float(clip[1]), num_segments=num_frames, fps=fps, max_frame=len(img_list)-1)
+    else:
+        frame_indices = get_frame_indices(
+            num_frames, vlen, sample=sample, local_num_frames=1, input_fps=fps
+        )
+
+    imgs = []
+    for idx in frame_indices:
+        frame_fname = os.path.join(video_path, img_list[idx])
+        if "s3://" in video_path and client is not None:
+            img_bytes = client.get(frame_fname)
+        else:
+            with open(frame_fname, 'rb') as f:
+                img_bytes = f.read()
+        img_np = np.frombuffer(img_bytes, np.uint8)
+        img = cv2.imdecode(img_np, cv2.IMREAD_COLOR)
+        cv2.cvtColor(img, cv2.COLOR_BGR2RGB, img)
+        imgs.append(img)
+
+    # print(f"\033[0;31m img_list={len(img_list)} video_path={video_path}, len(imgs)={len(imgs)}, frame_indices={frame_indices} num_frames={num_frames} \033[0m")
+    frames = np.array(imgs, dtype=np.uint8)
+
+    frames = torch.tensor(np.array(imgs), dtype=torch.uint8).permute(0, 3, 1, 2)  # (T, C, H, W), torch.uint8
+    sample_fps = num_frames / max(vlen, 1e-6) * fps
+
+    return frames, sample_fps
+
+def _read_video_av(
+    ele: dict,
+    client
+) -> (torch.Tensor, float):
+    """read video using decord.VideoReader
+
+    Args:
+        ele (dict): a dict contains the configuration of video.
+        support keys:
+            - video: the path of video. support "file://", "http://", "https://" and local path.
+            - video_start: the start time of video.
+            - video_end: the end time of video.
+    Returns:
+        torch.Tensor: the video tensor with shape (T, C, H, W).
+    """
+    video_path = ele["video"]
+    if 'media_dict' in ele:
+        media_dict = ele["media_dict"]
+    else:
+        media_dict = {}
+    if "start" in media_dict.keys():
+        clip = [media_dict['start'], media_dict['end']]
+    else:
+        clip = None
+
+    if clip is not None:
+        raise NotImplementedError("av don't support clip!!!")
+    if 's3://' in video_path and client is not None:
+        video_bytes = client.get(video_path)
+        byteio = io.BytesIO(video_bytes)
+        byteio.seek(0)
+        reader = av.open(byteio)
+    else:
+        byteio = None
+        reader = av.open(video_path)
+    frames = [f.to_rgb().to_ndarray() for f in reader.decode(video=0)]
+    vlen = len(frames)
+    sample = 'middle'
+    duration = get_pyav_video_duration(reader)
+    fps = vlen / float(duration)
+    num_frames = smart_nframes(ele, total_frames=vlen, video_fps=fps)
+    frame_indices = get_frame_indices(
+        num_frames, vlen, sample=sample,
+        input_fps=fps,  local_num_frames=1
+    )
+    frames = np.stack([frames[idx] for idx in frame_indices])  # (T, H, W, C), torch.uint8
+    frames = torch.tensor(frames).permute(0, 3, 1, 2)  # (T, C, H, W), torch.uint8
+    if byteio != None:
+        byteio.close()
+        
+    reader.close()
+    sample_fps = num_frames / max(vlen, 1e-6) * fps
+
+    return frames, sample_fps
+
+
+import numpy as np
+
+
+def sample_frames(key_timestamps, total_frames, num_frames, key_ratio, fps):
+    """
+    Samples num_frames from total_frames, where the frame density from key_timestamps is key_ratio times that of other parts.
+    
+    Parameters:
+        key_timestamps (list of tuple): Each element is a tuple containing start and end times in seconds.
+        total_frames (int): Total number of frames.
+        num_frames (int): Number of frames to sample.
+        key_ratio (float): The frame density from key_timestamps is key_ratio times that of other parts.
+        fps (int): Video frame rate (frames per second).
+        
+    Returns:
+        list: A list containing the sampled frame indices.
+    """
+
+    # Step 1: Convert key time periods to frame intervals
+    key_frame_ranges = []
+    for start_sec, end_sec in key_timestamps:
+        start_frame = int(start_sec * fps)
+        end_frame = min(int(end_sec * fps), total_frames - 1)
+        if start_frame <= end_frame:
+            key_frame_ranges.append((start_frame, end_frame))
+
+
+
+    # Step 2: Calculate the number of frames in key and non-key regions
+    key_frames_count = sum(end - start + 1 for start, end in key_frame_ranges)
+
+    non_key_frames_count = total_frames - key_frames_count
+
+    # Step 3: Allocate sample frame counts based on key_ratio
+    if non_key_frames_count == 0 and key_frames_count == 0:
+        return []
+    if non_key_frames_count == 0 and key_ratio == 0:
+        raise ValueError("No frames available for sampling.")
+
+    # Set weights: key region weight is key_ratio, non-key is 1
+    key_weight = key_ratio
+    non_key_weight = 1.0
+
+    total_weighted_frames = key_frames_count * key_weight + non_key_frames_count * non_key_weight
+
+    if total_weighted_frames == 0:
+        # Handle case where all weights are zero
+        key_sample_count = 0
+        non_key_sample_count = num_frames
+    else:
+        key_sample_count = round(num_frames * (key_frames_count * key_weight) / total_weighted_frames)
+        non_key_sample_count = num_frames - key_sample_count
+
+    # Step 4: Sample from key regions
+    key_samples = []
+    for start, end in key_frame_ranges:
+        if key_frames_count > 0:
+            num = max(1, round(key_sample_count * (end - start + 1) / key_frames_count))
+            samples = np.linspace(start, end, num=num, dtype=int)
+            key_samples.extend(samples)
+
+    # Step 5: Sample from non-key regions
+    non_key_samples = []
+
+    # Build a set of frames for non-key regions
+    key_set = set()
+    for start, end in key_frame_ranges:
+        key_set.update(range(start, end + 1))
+
+    non_key_frames = [i for i in range(total_frames) if i not in key_set]
+
+    # Uniformly sample non-key frames
+    if non_key_sample_count > 0 and len(non_key_frames) > 0:
+        indices = np.linspace(0, len(non_key_frames) - 1, num=non_key_sample_count, dtype=int)
+        non_key_samples = [non_key_frames[i] for i in indices]
+
+    # Combine results and sort
+    all_samples = sorted(set(key_samples + non_key_samples))
+
+    return all_samples
+
+def _read_video_decord(
+    ele: dict,
+    client = None,
+) -> (torch.Tensor, float):
+    """read video using decord.VideoReader
+
+    Args:
+        ele (dict): a dict contains the configuration of video.
+        support keys:
+            - video: the path of video. support "file://", "http://", "https://" and local path.
+            - video_start: the start time of video.
+            - video_end: the end time of video.
+    Returns:
+        torch.Tensor: the video tensor with shape (T, C, H, W).
+    """
+    import decord
+    video_path = ele["video"]
+    
+    if video_path.endswith('.avi'):
+        return _read_video_av(ele, client)
+    st = time.time()
+
+    if 's3://' in video_path and client is not None:
+        video_bytes = client.get(video_path)
+        if video_bytes is None or len(video_bytes) == 0:
+            raise ValueError(f"Can't read byte from {video_path}!")
+        byteio = BytesIO(video_bytes)
+        vr = decord.VideoReader(byteio, num_threads=1)
+    else:
+        byteio = None
+        vr = decord.VideoReader(video_path, num_threads=1)
+
+    # TODO: support start_pts and end_pts
+    if 'video_start' in ele or 'video_end' in ele:
+        raise NotImplementedError("not support start_pts and end_pts in decord for now.")
+    total_frames, video_fps = len(vr), vr.get_avg_fps()
+    logger.info(f"decord:  {video_path=}, {total_frames=}, {video_fps=}, time={time.time() - st:.3f}s")
+    nframes = smart_nframes(ele, total_frames=total_frames, video_fps=video_fps)
+    # import pdb; pdb.set_trace()
+    if 'key_time' in ele and ele['key_time'] is not None:
+        try:
+            idx = sample_frames(ele['key_time'], total_frames-1, nframes, 1.5, vr.get_avg_fps())
+        except Exception as e:
+            idx = torch.linspace(0, total_frames - 1, nframes).round().long().tolist()
+    else:
+        idx = torch.linspace(0, total_frames - 1, nframes).round().long().tolist()
+    
+    if not idx:
+        if total_frames > 0:
+            idx = [0] * nframes # Fallback if sampling returns empty
+        else: # Cannot get any frames from video
+            return torch.empty(0, 3, 224, 224), 0.0
+
+    video = vr.get_batch(idx).asnumpy()
+    video = torch.tensor(video).permute(0, 3, 1, 2)  # Convert to TCHW format
+    sample_fps = nframes / max(total_frames, 1e-6) * video_fps
+    return video, sample_fps
+
+
+VIDEO_READER_BACKENDS = {
+    "decord": _read_video_decord,
+    'img': _read_video_img,
+    'frame': _read_video_img,
+    'av': _read_video_av,
+    'torchvision':_read_video_torchvision
+}
+
+FORCE_QWENVL_VIDEO_READER = os.getenv("FORCE_QWENVL_VIDEO_READER", None)
+
+
+@lru_cache(maxsize=1)
+def get_video_reader_backend() -> str:
+    if FORCE_QWENVL_VIDEO_READER is not None:
+        video_reader_backend = FORCE_QWENVL_VIDEO_READER
+    elif is_decord_available():
+        video_reader_backend = "decord"
+    else:
+        video_reader_backend = "torchvision"
+    logger.info(f"qwen-vl-utils using {video_reader_backend} to read video.")
+    return video_reader_backend
+
+def fetch_video(ele: dict, client = None, image_factor: int = IMAGE_FACTOR, return_video_sample_fps: bool = False) -> torch.Tensor | list[Image.Image]:
+    video_reader_backend = get_video_reader_backend()
+    # import pdb; pdb.set_trace()
+    if isinstance(ele["video"], list):
+        if len(ele["video"]) > 1 and isinstance(ele["video"][1], dict) and 'video_read_type' in ele['video'][1]:
+            video_reader_backend = ele['video'][1]['video_read_type']
+            ele['video'] = ele['video'][0]
+            
+    if isinstance(ele["video"], str):
+        
+        # print(f'video_reader_backend:{video_reader_backend}')
+        # import pdb; pdb.set_trace()
+        try:
+            video, sample_fps = VIDEO_READER_BACKENDS[video_reader_backend](ele, client=client)
+        except Exception as e:
+            logger.warning(f"video_reader_backend {video_reader_backend} error, trying other backends. msg: {e}")
+            try:
+                video, sample_fps = VIDEO_READER_BACKENDS["av"](ele, client=client)
+            except Exception as e2:
+                logger.error(f"All video backends failed. Last error: {e2}")
+                raise e2
+
+
+        nframes, _, height, width = video.shape if video.ndim == 4 else (0,0,0,0)
+        
+        if nframes == 0: # Handle empty video
+            if return_video_sample_fps:
+                return video, 0.0
+            return video
+
+        min_pixels = ele.get("min_pixels", VIDEO_MIN_PIXELS)
+        total_pixels = ele.get("total_pixels", VIDEO_TOTAL_PIXELS)
+        max_pixels = max(min(VIDEO_MAX_PIXELS, total_pixels / nframes * FRAME_FACTOR), int(min_pixels * 1.05))
+        max_pixels_supposed = ele.get("max_pixels", max_pixels)
+        if max_pixels_supposed > max_pixels:
+            logger.warning(f"The given max_pixels[{max_pixels_supposed}] exceeds limit[{max_pixels}].")
+        max_pixels = min(max_pixels_supposed, max_pixels)
+
+        if "resized_height" in ele and "resized_width" in ele:
+            resized_height, resized_width = smart_resize(
+                ele["resized_height"],
+                ele["resized_width"],
+                factor=image_factor,
+            )
+        else:
+            resized_height, resized_width = smart_resize(
+                height,
+                width,
+                factor=image_factor,
+                min_pixels=min_pixels,
+                max_pixels=max_pixels,
+            )
+        if resized_height > 0 and resized_width > 0:
+            video = transforms.functional.resize(
+                video,
+                [resized_height, resized_width],
+                interpolation=InterpolationMode.BICUBIC,
+                antialias=True,
+            ).float()
+        if return_video_sample_fps:
+            return video, sample_fps
+        return video
+    else:
+        assert isinstance(ele["video"], (list, tuple))
+        process_info = ele.copy()
+        process_info.pop("type", None)
+        process_info.pop("video", None)
+        images = [
+            fetch_image({"image": video_element, **process_info}, size_factor=image_factor)
+            for video_element in ele["video"]
+        ]
+        nframes = ceil_by_factor(len(images), FRAME_FACTOR)
+        if len(images) < nframes:
+            images.extend([images[-1]] * (nframes - len(images)))
+        if return_video_sample_fps:
+            return images, process_info.pop("fps", 2.0)
+        return images
+
+def extract_vision_info(conversations: list[dict] | list[list[dict]]) -> list[dict]:
+    vision_infos = []
+    if not conversations or not isinstance(conversations[0], (list, dict)):
+        return vision_infos
+        
+    if isinstance(conversations[0], dict):
+        conversations = [conversations]
+    for conversation in conversations:
+        for message in conversation:
+            if isinstance(message.get("content"), list):
+                for ele in message["content"]:
+                    if (
+                        ele.get("type") in ("image", "image_url", "video")
+                    ):
+                        vision_infos.append(ele)
+    return vision_infos
+
+
+def process_vision_info(
+    conversations: list[dict] | list[list[dict]],
+    return_video_kwargs: bool = False,
+    client = None
+) -> tuple[list[Image.Image] | None, list[torch.Tensor | list[Image.Image]] | None, Optional[dict]]:
+
+    vision_infos = extract_vision_info(conversations)
+    ## Read images or videos
+    image_inputs = []
+    video_inputs = []
+    video_sample_fps_list = []
+    for vision_info in vision_infos:
+        if vision_info.get("type") in ("image", "image_url"):
+            image_inputs.append(fetch_image(vision_info,client=client))
+        elif vision_info.get("type") == "video":
+            video_input, video_sample_fps = fetch_video(vision_info, return_video_sample_fps=True, client=client)
+            video_sample_fps_list.append(video_sample_fps)
+            video_inputs.append(video_input)
+        else:
+            raise ValueError("`image`, `image_url` or `video` type not found in content.")
+    if len(image_inputs) == 0:
+        image_inputs = None
+    if len(video_inputs) == 0:
+        video_inputs = None
+    if return_video_kwargs:
+        return image_inputs, video_inputs, {'fps': video_sample_fps_list}
+    return image_inputs, video_inputs

src/run_inference.py

@@ -0,0 +1,135 @@
+import torch
+import re
+import ast
+import os
+import sys
+import argparse
+from transformers import Qwen3VLForConditionalGeneration, AutoProcessor
+from my_vision_process import process_vision_info, client
+
+# --- Prompt Definitions ---
+QA_THINK_GLUE = """Answer the question: "[QUESTION]" according to the content of the video. 
+
+Output your think process within the <think> </think> tags.
+
+Then, provide your answer within the <answer> </answer> tags. At the same time, in the <glue> </glue> tags, present the precise time period in seconds of the video clips on which you base your answer in the format of [(s1, e1), (s2, e2), ...]. For example: <think>...</think><answer>A</answer><glue>[(5.2, 10.4)]</glue>.
+"""
+
+QA_THINK = """Answer the question: "[QUESTION]" according to the content of the video.
+
+Output your think process within the <think> </think> tags.
+
+Then, provide your answer within the <answer> </answer> tags. For example: <think>...</think><answer>A</answer>.
+"""
+
+def setup_model():
+    """Loads and returns the model and processor onto the GPU."""
+    model_path = "OpenGVLab/VideoChat-R1_5"
+    print(f"Loading model from {model_path} onto GPU...")
+    
+    try:
+        import flash_attn
+        attn_implementation = "flash_attention_2"
+        print("flash-attn is available, using 'flash_attention_2'.")
+    except ImportError:
+        print("flash-attn not installed. Falling back to 'sdpa' (PyTorch's native attention).")
+        attn_implementation = "sdpa"
+
+    model = Qwen3VLForConditionalGeneration.from_pretrained(
+        model_path,
+        torch_dtype=torch.bfloat16,
+        device_map="cuda", # Explicitly load the model on the GPU
+        attn_implementation=attn_implementation
+    ).eval()
+    processor = AutoProcessor.from_pretrained(model_path)
+    print("Model and processor loaded successfully onto GPU.")
+    return model, processor
+
+def inference(video_path, prompt, model, processor, max_new_tokens=2048, client=None, pred_glue=None):
+    """Runs a single inference pass on the model."""
+    messages = [
+        {"role": "user", "content": [
+                {"type": "video", 
+                "video": video_path,
+                'key_time': pred_glue,
+                "total_pixels": 128*12 * 28 * 28, 
+                "min_pixels": 128 * 28 * 28,
+                },
+                {"type": "text", "text": prompt},
+            ]
+        },
+    ]
+    text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    image_inputs, video_inputs, video_kwargs = process_vision_info(messages, return_video_kwargs=True, client=client)
+    fps_inputs = video_kwargs['fps'][0]
+    inputs = processor(text=[text], images=image_inputs, videos=video_inputs, fps=fps_inputs, padding=True, return_tensors="pt")
+    inputs = {k: v.to(model.device) for k, v in inputs.items()}
+
+    with torch.no_grad():
+        output_ids = model.generate(**inputs, max_new_tokens=max_new_tokens, use_cache=True)
+
+    generated_ids = [output_ids[i][len(inputs.input_ids[i]):] for i in range(len(output_ids))]
+    output_text = processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+    return output_text[0]
+
+def main(args):
+    """Main function to orchestrate the multi-perception inference process."""
+    if not torch.cuda.is_available():
+        print("Error: CUDA is not available. This script requires a GPU to run.", file=sys.stderr)
+        sys.exit(1)
+    print("CUDA is available. Proceeding with GPU setup.")
+
+    if not os.path.exists(args.video_path):
+        print(f"Error: Video file not found at '{args.video_path}'", file=sys.stderr)
+        sys.exit(1)
+
+    model, processor = setup_model()
+    
+    answers = []
+    pred_glue = None
+
+    print(f"\nStarting inference for video: '{args.video_path}'")
+    print(f"Question: '{args.question}'")
+    print(f"Number of perception iterations: {args.num_perceptions}\n")
+
+    for perception in range(args.num_perceptions):
+        print(f"--- Perception Iteration {perception + 1}/{args.num_perceptions} ---")
+
+        if perception < args.num_perceptions - 1:
+            current_prompt = QA_THINK_GLUE.replace("[QUESTION]", args.question)
+        else:
+            current_prompt = QA_THINK.replace("[QUESTION]", args.question)
+        
+        ans = inference(
+            args.video_path, current_prompt, model, processor,
+            client=client, pred_glue=pred_glue
+        )
+
+        print(f"Model Raw Output: {ans}")
+        answers.append(ans)
+        
+        pred_glue = None
+        try:
+            pattern_glue = r'<glue>(.*?)</glue>'
+            match_glue = re.search(pattern_glue, ans, re.DOTALL)
+            if match_glue:
+                glue_str = match_glue.group(1).strip()
+                pred_glue = ast.literal_eval(glue_str)
+                print(f"Found glue for next iteration: {pred_glue}\n")
+            else:
+                print("No glue found for next iteration.\n")
+        except Exception as e:
+            print(f"Could not parse glue from output: {e}\n")
+            pred_glue = None
+
+    print("\n--- Final Answer ---")
+    final_answer = answers[-1] if answers else "No answer was generated."
+    print(final_answer)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run video chat inference from the command line.")
+    parser.add_argument("video_path", type=str, help="Path to the video file.")
+    parser.add_argument("question", type=str, help="Question to ask about the video.")
+    parser.add_argument("--num_perceptions", type=int, default=3, help="Number of perception iterations to run.")
+    args = parser.parse_args()
+    main(args)

src/toon_parser.py

@@ -0,0 +1,282 @@
+import re
+import logging
+import csv
+from io import StringIO
+
+logger = logging.getLogger(__name__)
+
+def parse_toon_line(line_def, data_line):
+    """
+    Parses a single TOON data line based on headers.
+    Handles CSV-style quoting for text fields.
+    Robustly handles '9/10' or '(9)' formats in numeric fields.
+    """
+    if not data_line or data_line.isspace():
+        return {}
+
+    try:
+        # Use csv module to handle quoted strings
+        reader = csv.reader(StringIO(data_line), skipinitialspace=True)
+        try:
+            values = next(reader)
+        except StopIteration:
+            values = []
+        
+        cleaned_values = []
+        for v in values:
+            v_str = v.strip()
+            # Remove parens: (9) -> 9
+            v_str = v_str.replace('(', '').replace(')', '')
+            # Handle fractional scores: 9/10 -> 9
+            if '/' in v_str and any(c.isdigit() for c in v_str):
+                parts = v_str.split('/')
+                # If first part is digit, take it. 
+                if parts[0].strip().isdigit():
+                    v_str = parts[0].strip()
+            cleaned_values.append(v_str)
+
+        headers = line_def.get('headers', [])
+        
+        # Ensure values match headers length if possible, or pad
+        if len(cleaned_values) < len(headers):
+            cleaned_values += [""] * (len(headers) - len(cleaned_values))
+        elif len(cleaned_values) > len(headers):
+            cleaned_values = cleaned_values[:len(headers)]
+
+        return dict(zip(headers, cleaned_values))
+    except Exception as e:
+        logger.error(f"Error parsing TOON line '{data_line}': {e}")
+        return {}
+
+def fuzzy_extract_scores(text: str) -> dict:
+    """
+    Fallback method. Scans text for key metrics followed near-immediately by a number.
+    Handles: "Visual: 9", "Visual - 9", "Visual: 9/10", "Accuracy: 9/10"
+    """
+    scores = {
+        'visual': '0', 'audio': '0', 'source': '0', 'logic': '0', 'emotion': '0',
+        'video_audio': '0', 'video_caption': '0', 'audio_caption': '0'
+    }
+    
+    # Mappings: Regex Pattern -> Score Key
+    mappings = [
+        ('visual', 'visual'),
+        ('visual.*?integrity', 'visual'),
+        ('accuracy', 'visual'), # Fallback
+        ('audio', 'audio'),
+        ('source', 'source'),
+        ('logic', 'logic'),
+        ('emotion', 'emotion'),
+        (r'video.*?audio', 'video_audio'),
+        (r'video.*?caption', 'video_caption'),
+        (r'audio.*?caption', 'audio_caption')
+    ]
+
+    for pattern_str, key in mappings:
+        pattern = re.compile(fr'(?i){pattern_str}.*?[:=\-\s\(]+(\b10\b|\b\d\b)(?:/10)?')
+        match = pattern.search(text)
+        if match:
+            if scores[key] == '0':
+                scores[key] = match.group(1)
+    
+    return scores
+
+def parse_veracity_toon(text: str) -> dict:
+    """
+    Parses the Veracity Vector TOON output into a standardized dictionary.
+    Handles "Simple", "Reasoning", and new "Modalities" blocks.
+    Robust against Markdown formatting artifacts and nested reports.
+    """
+    if not text:
+        return {}
+
+    # 1. Cleanup
+    text = re.sub(r'```\w*', '', text)
+    text = re.sub(r'```', '', text)
+    text = text.strip()
+
+    parsed_sections = {}
+
+    # 2. Robust Regex for TOON Block Headers
+    # Matches: key : type [ count ] { headers } :
+    block_pattern = re.compile(
+        r'([a-zA-Z0-9_]+)\s*:\s*(?:\w+\s*)?(?:\[\s*(\d+)\s*\])?\s*\{\s*(.*?)\s*\}\s*:\s*', 
+        re.MULTILINE
+    )
+    
+    matches = list(block_pattern.finditer(text))
+    
+    for i, match in enumerate(matches):
+        key = match.group(1).lower()
+        # Default to 1 if count is missing
+        count = int(match.group(2)) if match.group(2) else 1
+        headers_str = match.group(3)
+        headers = [h.strip().lower() for h in headers_str.split(',')]
+        
+        start_idx = match.end()
+        # End at next match or end of text
+        end_idx = matches[i+1].start() if i + 1 < len(matches) else len(text)
+        block_content = text[start_idx:end_idx].strip()
+        
+        lines = [line.strip() for line in block_content.splitlines() if line.strip()]
+        
+        data_items = []
+        valid_lines = [l for l in lines if len(l) > 1] 
+        
+        for line in valid_lines[:count]:
+            item = parse_toon_line({'key': key, 'headers': headers}, line)
+            data_items.append(item)
+            
+        if count == 1 and data_items:
+            parsed_sections[key] = data_items[0]
+        else:
+            parsed_sections[key] = data_items
+
+    # --- Flatten logic to standardized structure ---
+    flat_result = {
+        'veracity_vectors': {
+            'visual_integrity_score': '0',
+            'audio_integrity_score': '0',
+            'source_credibility_score': '0',
+            'logical_consistency_score': '0',
+            'emotional_manipulation_score': '0'
+        },
+        'modalities': {
+            'video_audio_score': '0',
+            'video_caption_score': '0',
+            'audio_caption_score': '0'
+        },
+        'video_context_summary': '',
+        'political_bias': {},
+        'criticism_level': {},
+        'sentiment_and_bias': '',
+        'tags': [],
+        'factuality_factors': {},
+        'disinformation_analysis': {},
+        'final_assessment': {}
+    }
+    
+    got_vectors = False
+    got_modalities = False
+
+    # 1. Process 'vectors'
+    vectors_data = parsed_sections.get('vectors', [])
+    if isinstance(vectors_data, dict): # Simple schema
+        v = vectors_data
+        if any(val and val != '0' for val in v.values()):
+            if 'visual' in v: flat_result['veracity_vectors']['visual_integrity_score'] = v['visual']
+            if 'audio' in v: flat_result['veracity_vectors']['audio_integrity_score'] = v['audio']
+            if 'source' in v: flat_result['veracity_vectors']['source_credibility_score'] = v['source']
+            if 'logic' in v: flat_result['veracity_vectors']['logical_consistency_score'] = v['logic']
+            if 'emotion' in v: flat_result['veracity_vectors']['emotional_manipulation_score'] = v['emotion']
+            got_vectors = True
+
+    elif isinstance(vectors_data, list): # Reasoning schema
+        for item in vectors_data:
+            cat = item.get('category', '').lower()
+            score = item.get('score', '0')
+            if score and score != '0': 
+                got_vectors = True
+            if 'visual' in cat: flat_result['veracity_vectors']['visual_integrity_score'] = score
+            elif 'audio' in cat: flat_result['veracity_vectors']['audio_integrity_score'] = score
+            elif 'source' in cat: flat_result['veracity_vectors']['source_credibility_score'] = score
+            elif 'logic' in cat: flat_result['veracity_vectors']['logical_consistency_score'] = score
+            elif 'emotion' in cat: flat_result['veracity_vectors']['emotional_manipulation_score'] = score
+
+    # 2. Process 'modalities'
+    modalities_data = parsed_sections.get('modalities', [])
+    if isinstance(modalities_data, dict): # Simple schema
+        m = modalities_data
+        for k, v in m.items():
+            k_clean = k.lower().replace(' ', '').replace('-', '').replace('_', '')
+            if 'videoaudio' in k_clean: flat_result['modalities']['video_audio_score'] = v
+            elif 'videocaption' in k_clean: flat_result['modalities']['video_caption_score'] = v
+            elif 'audiocaption' in k_clean: flat_result['modalities']['audio_caption_score'] = v
+            if v and v != '0': got_modalities = True
+
+    elif isinstance(modalities_data, list): # Reasoning schema
+        for item in modalities_data:
+            cat = item.get('category', '').lower().replace(' ', '').replace('-', '').replace('_', '')
+            score = item.get('score', '0')
+            if score and score != '0':
+                got_modalities = True
+            if 'videoaudio' in cat: flat_result['modalities']['video_audio_score'] = score
+            elif 'videocaption' in cat: flat_result['modalities']['video_caption_score'] = score
+            elif 'audiocaption' in cat: flat_result['modalities']['audio_caption_score'] = score
+
+    # --- FUZZY FALLBACK ---
+    if not got_vectors or not got_modalities:
+        fuzzy_scores = fuzzy_extract_scores(text)
+        if not got_vectors:
+            flat_result['veracity_vectors']['visual_integrity_score'] = fuzzy_scores['visual']
+            flat_result['veracity_vectors']['audio_integrity_score'] = fuzzy_scores['audio']
+            flat_result['veracity_vectors']['source_credibility_score'] = fuzzy_scores['source']
+            flat_result['veracity_vectors']['logical_consistency_score'] = fuzzy_scores['logic']
+            flat_result['veracity_vectors']['emotional_manipulation_score'] = fuzzy_scores['emotion']
+        if not got_modalities:
+            flat_result['modalities']['video_audio_score'] = fuzzy_scores['video_audio']
+            flat_result['modalities']['video_caption_score'] = fuzzy_scores['video_caption']
+            flat_result['modalities']['audio_caption_score'] = fuzzy_scores['audio_caption']
+
+    # 3. Factuality
+    f = parsed_sections.get('factuality', {})
+    if isinstance(f, list): f = f[0] if f else {}
+    flat_result['factuality_factors'] = {
+        'claim_accuracy': f.get('accuracy', 'Unverifiable'),
+        'evidence_gap': f.get('gap', ''),
+        'grounding_check': f.get('grounding', '')
+    }
+
+    # 4. Disinfo
+    d = parsed_sections.get('disinfo', {})
+    if isinstance(d, list): d = d[0] if d else {}
+    flat_result['disinformation_analysis'] = {
+        'classification': d.get('class', 'None'),
+        'intent': d.get('intent', 'None'),
+        'threat_vector': d.get('threat', 'None')
+    }
+
+    # 5. Final Assessment
+    fn = parsed_sections.get('final', {})
+    if isinstance(fn, list): fn = fn[0] if fn else {}
+    flat_result['final_assessment'] = {
+        'veracity_score_total': fn.get('score', '0'),
+        'reasoning': fn.get('reasoning', '')
+    }
+
+    # 6. Tags (New)
+    t = parsed_sections.get('tags', {})
+    if isinstance(t, list): t = t[0] if t else {}
+    raw_tags = t.get('keywords', '')
+    if raw_tags:
+        flat_result['tags'] = [x.strip() for x in raw_tags.split(',')]
+
+    # 7. Summary
+    s = parsed_sections.get('summary', {})
+    if isinstance(s, list): s = s[0] if s else {}
+    flat_result['video_context_summary'] = s.get('text', '')
+
+    # 8. Political Bias (New)
+    pb = parsed_sections.get('political_bias', {})
+    if isinstance(pb, list): pb = pb[0] if pb else {}
+    flat_result['political_bias'] = {
+        'score': pb.get('score', '0'),
+        'reasoning': pb.get('reasoning', '')
+    }
+
+    # 9. Criticism Level (New)
+    cl = parsed_sections.get('criticism_level', {})
+    if isinstance(cl, list): cl = cl[0] if cl else {}
+    flat_result['criticism_level'] = {
+        'score': cl.get('score', '0'),
+        'reasoning': cl.get('reasoning', '')
+    }
+
+    # 10. Sentiment and Bias (New)
+    sb = parsed_sections.get('sentiment_and_bias', {})
+    if isinstance(sb, list): sb = sb[0] if sb else {}
+    flat_result['sentiment_and_bias'] = sb.get('text', '')
+
+    flat_result['raw_parsed_structure'] = parsed_sections
+    
+    return flat_result

src/transcription.py

@@ -0,0 +1,59 @@
+import whisper
+import logging
+from pathlib import Path
+import os
+
+LITE_MODE = os.getenv("LITE_MODE", "false").lower() == "true"
+
+logger = logging.getLogger(__name__)
+transcription_model = None
+
+def load_model():
+    """Loads the Whisper transcription model."""
+    if LITE_MODE:
+        logger.info("LITE_MODE is enabled. Skipping Whisper model loading.")
+        return
+
+    global transcription_model
+    if transcription_model is None:
+        try:
+            # Using 'base.en' for a good balance of speed and accuracy with English videos.
+            # For multilingual support, 'base' could be used.
+            logger.info("Loading 'base.en' Whisper model for transcription...")
+            transcription_model = whisper.load_model("base.en")
+            logger.info("Whisper model loaded successfully.")
+        except Exception as e:
+            logger.error(f"Failed to load Whisper model: {e}", exc_info=True)
+            # The app can continue without transcription, but we should log the error.
+            transcription_model = None
+
+def generate_transcript(audio_path_str: str) -> str:
+    """
+    Transcribes the given audio file and saves the transcript as a .vtt file.
+    Returns the path to the generated .vtt file.
+    """
+    if transcription_model is None:
+        logger.warning("Transcription model is not available. Cannot generate transcript.")
+        return None
+
+    try:
+        audio_path = Path(audio_path_str)
+        logger.info(f"Starting transcription for: {audio_path.name}")
+
+        # The result object contains the transcript in various formats.
+        result = transcription_model.transcribe(audio_path_str, verbose=False)
+
+        # Define the output VTT path
+        vtt_path = audio_path.with_suffix('.vtt')
+
+        # Use whisper's built-in VTT writer
+        from whisper.utils import get_writer
+        writer = get_writer("vtt", str(vtt_path.parent))
+        writer(result, str(audio_path.name))
+        
+        logger.info(f"Transcription complete. VTT file saved to: {vtt_path}")
+        return str(vtt_path)
+
+    except Exception as e:
+        logger.error(f"An error occurred during transcription for {audio_path_str}: {e}", exc_info=True)
+        return None

start.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+# 1. Start Python FastAPI in the background
+# We set PYTHONPATH to include the /app/src directory so imports work correctly
+# We run from /app so that data/ and videos/ directories are created in the root volume mount
+echo "Starting Python Inference Engine..."
+export PYTHONPATH=$PYTHONPATH:/app/src
+python -m uvicorn src.app:app --host 127.0.0.1 --port 8001 &
+
+# Wait for Python to initialize
+sleep 5
+
+# 2. Start Golang Web Server
+echo "Starting Go Web Server..."
+# FIXED: Run the binary from the system path
+/usr/local/bin/vchat-server