First commit

adapter.py

@@ -0,0 +1,764 @@
+from __future__ import annotations
+
+import base64
+import json
+import os
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Union
+
+import requests
+
+
+import io
+import re
+import random
+from dataclasses import dataclass
+from typing import List, Dict, Callable, Optional, Tuple, Union
+
+import streamlit as st
+from PIL import Image, ImageDraw
+import pandas as pd
+from io import BytesIO
+
+class BaseAdapterError(RuntimeError):
+    pass
+
+@dataclass
+class BaseAdapter:
+    provider: str
+    model: str
+    api_key: Optional[str] = None
+    timeout: float = 60.0
+    base_url: Optional[str] = None
+    extra_headers: Dict[str, str] = field(default_factory=dict)
+
+    OPENAI = 'openai'
+    ANTHROPIC = 'anthropic'
+    GEMINI = 'gemini'
+    MISTRAL = 'mistral'
+    GROK = 'grok'
+    COHERE = 'cohere'
+    TOGETHER = 'together'
+    providers = [OPENAI,
+            ANTHROPIC, 
+            GEMINI, 
+            MISTRAL, 
+            GROK,
+            COHERE,
+            TOGETHER  ]
+    def __post_init__(self) -> None:
+        self.provider = self.provider.lower().strip()
+        if self.api_key is None:
+            env_keys = {
+                "openai": "OPENAI_API_KEY",
+                "anthropic": "ANTHROPIC_API_KEY",
+                "gemini": "GEMINI_API_KEY",
+                "mistral": "MISTRAL_API_KEY",
+                "grok" : "XAI_API_KEY",
+                "cohere": "COHERE_API_KEY",
+                "together": "TOGETHER_API_KEY",
+            }
+            env_var = env_keys.get(self.provider)
+            if env_var:
+                self.api_key = os.getenv(env_var)
+        if not self.api_key and self.provider not in ("gemini",):
+            raise BaseAdapterError(f"Missing api_key for {self.provider}. Set via environment.")
+
+    @staticmethod
+    def list_models(provider: str, api_key: Optional[str] = None, base_url: Optional[str] = None, timeout: float = 60.0) -> List[str]:
+        p = provider.lower().strip()
+        if p == "openai":
+            url = (base_url or "https://api.openai.com") + "/v1/models"
+            headers = {"Authorization": f"Bearer {api_key or os.getenv('OPENAI_API_KEY')}"}
+            r = requests.get(url, headers=headers, timeout=timeout)
+            BaseAdapter._raise_for_status_static(r)
+            return [m["id"] for m in r.json().get("data", [])]
+        if p == "anthropic":
+            return [
+                "claude-3-5-sonnet-latest",
+                "claude-3-5-haiku-latest",
+                "claude-3-opus-latest",
+            ]
+        if p == "gemini":
+            key = api_key or os.getenv("GEMINI_API_KEY")
+            if not key:
+                raise BaseAdapterError("Missing GEMINI_API_KEY.")
+            url = (base_url or "https://generativelanguage.googleapis.com") + f"/v1beta/models?key={key}"
+            r = requests.get(url, timeout=timeout)
+            BaseAdapter._raise_for_status_static(r)
+            return [m["name"] for m in r.json().get("models", [])]
+        if p == "grok":
+            key = api_key or os.getenv("XAI_API_KEY")
+            url = (base_url or "https://api.x.ai") + "/v1/models"
+            headers = {"Authorization": f"Bearer {key}"}
+            r = requests.get(url, headers=headers, timeout=timeout)
+            BaseAdapter._raise_for_status_static(r)
+            return [m["id"] for m in r.json().get("data", [])]        
+        if p == "mistral":
+            url = (base_url or "https://api.mistral.ai") + "/v1/models"
+            headers = {"Authorization": f"Bearer {api_key or os.getenv('MISTRAL_API_KEY')}"}
+            r = requests.get(url, headers=headers, timeout=timeout)
+            BaseAdapter._raise_for_status_static(r)
+            return [m["id"] for m in r.json().get("data", [])]
+        if p == "cohere":
+            url = (base_url or "https://api.cohere.ai") + "/v1/models"
+            headers = {"Authorization": f"Bearer {api_key or os.getenv('COHERE_API_KEY')}"}
+            r = requests.get(url, headers=headers, timeout=timeout)
+            BaseAdapter._raise_for_status_static(r)
+            return [m["name"] for m in r.json().get("models", [])]
+        if p == "together":
+            url = (base_url or "https://api.together.xyz") + "/v1/models"
+            headers = {"Authorization": f"Bearer {api_key or os.getenv('TOGETHER_API_KEY')}"}
+            r = requests.get(url, headers=headers, timeout=timeout)
+            BaseAdapter._raise_for_status_static(r)
+            return [m["id"] for m in r.json().get("data", [])]
+        raise BaseAdapterError(f"Unsupported provider: {p}")
+
+    # ---------- Utilities ---------- #
+
+    @staticmethod
+    def _raise_for_status_static(response: requests.Response) -> None:
+        if 200 <= response.status_code < 300:
+            return
+        try:
+            detail = response.json()
+            msg = json.dumps(detail)
+        except Exception:
+            msg = response.text
+        raise BaseAdapterError(f"HTTP {response.status_code}: {msg}")
+
+    def _raise_for_status(self, response: requests.Response) -> None:
+        return self._raise_for_status_static(response)
+
+    @staticmethod
+    def _detect_mime(b: bytes) -> str:
+        if len(b) >= 8 and b[:8] == b"\x89PNG\r\n\x1a\n":
+            return "image/png"
+        if len(b) >= 3 and b[:3] == b"\xff\xd8\xff":
+            return "image/jpeg"
+        if len(b) >= 6 and b[:6] in (b"GIF87a", b"GIF89a"):
+            return "image/gif"
+        if len(b) >= 12 and b[8:12] == b"WEBP":
+            return "image/webp"
+        return "application/octet-stream"
+
+    @staticmethod
+    def _normalize_image(image: Union[str, bytes], default_mime: str = "image/png") -> tuple[str, str, str]:
+        """Return (data_url, base64_str, mime_type) for the given image input.
+        Accepts bytes, base64 string, data URL, or local file path.
+        """
+        if isinstance(image, bytes):
+            b64 = base64.b64encode(image).decode()
+            mime = BaseAdapter._detect_mime(image)
+            if mime == "application/octet-stream":
+                mime = default_mime
+            return f"data:{mime};base64,{b64}", b64, mime
+        if isinstance(image, str):
+            if image.startswith("data:"):
+                header, b64 = image.split(",", 1)
+                # data:image/png;base64,XXXX
+                mime = header.split(";")[0].split(":", 1)[1] or default_mime
+                return image, b64, mime
+            if os.path.exists(image):
+                with open(image, "rb") as f:
+                    raw = f.read()
+                b64 = base64.b64encode(raw).decode()
+                mime = BaseAdapter._detect_mime(raw)
+                if mime == "application/octet-stream":
+                    mime = default_mime
+                return f"data:{mime};base64,{b64}", b64, mime
+            # assume bare base64 string
+            b64 = image
+            mime = default_mime
+            return f"data:{mime};base64,{b64}", b64, mime
+        raise BaseAdapterError("Unsupported image type; pass bytes, path, base64 string, or data URL.")
+
+
+
+class OpenaiAdapter(BaseAdapter):
+    provider: str
+    model: str
+    api_key: Optional[str] = None
+    timeout: float = 60.0
+    base_url: Optional[str] = None
+    extra_headers: Dict[str, str] = field(default_factory=dict)
+
+    def __init__(self, model_name):
+        super().__init__(BaseAdapter.OPENAI, model_name)
+
+    def generate(self, prompt: str, system: Optional[str] = None, image: Optional[List[Union[str, bytes, Image]] ] = None, **kwargs: Any) -> str:
+        url = (self.base_url or "https://api.openai.com") + "/v1/chat/completions"
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json", **self.extra_headers}
+        messages = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        content = [{"type": "text", "text": prompt}]
+        data_url = None
+        if image is not None:
+            if not isinstance(image, list):
+                image = [image]
+            
+            for img in image:
+                data_url, _b64, _mime = self._normalize_image(img, default_mime="image/png")
+                content.append({"type": "image_url", "image_url": {"url": data_url}})
+        messages.append({"role": "user", "content": content})
+        payload = {"model": self.model, "messages": messages}
+        r = requests.post(url, headers=headers, json=payload, timeout=self.timeout)
+        self._raise_for_status(r)
+        data = r.json()
+        return data["choices"][0]["message"]["content"].strip()
+
+
+class AnthropicAdapter(BaseAdapter):
+    provider: str
+    model: str
+    api_key: Optional[str] = None
+    timeout: float = 60.0
+    base_url: Optional[str] = None
+    extra_headers: Dict[str, str] = field(default_factory=dict)
+
+    def __init__(self, model_name):
+        super().__init__(BaseAdapter.ANTHROPIC, model_name)
+        
+    def generate(self, prompt: str, system: Optional[str] = None, image: Optional[List[Union[str, bytes, Image]] ] = None, **kwargs: Any) -> str:
+        url = (self.base_url or "https://api.anthropic.com") + "/v1/messages"
+        headers = {
+            "x-api-key": self.api_key or "",
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+            **self.extra_headers,
+        }
+        content_items: List[Dict[str, Any]] = [{"type": "text", "text": prompt}]
+        if image is not None:
+            if not isinstance(image, list):
+                image = [image]
+            for img in image:
+                _data_url, b64, mime = self._normalize_image(img, default_mime="image/png")
+                content_items.append({
+                    "type": "image",
+                    "source": {
+                        "type": "base64",
+                        "media_type": mime,
+                        "data": b64,
+                    },
+                })
+        payload: Dict[str, Any] = {
+            "model": self.model,
+            "max_tokens": kwargs.get("max_tokens", 1024),
+            "messages": [{"role": "user", "content": content_items}],
+        }
+        if system:
+            payload["system"] = system
+        r = requests.post(url, headers=headers, json=payload, timeout=self.timeout)
+        self._raise_for_status(r)
+        data = r.json()
+        parts = data.get("content", [])
+        return "".join(p.get("text", "") for p in parts if p.get("type") == "text").strip()
+
+
+
+
+class GeminiAdapter(BaseAdapter):
+    provider: str
+    model: str
+    api_key: Optional[str] = None
+    timeout: float = 60.0
+    base_url: Optional[str] = None
+    extra_headers: Dict[str, str] = field(default_factory=dict)
+
+    def __init__(self, model_name):
+        super().__init__(BaseAdapter.GEMINI, model_name)
+
+    def generate(self, prompt: str, system: Optional[str] = None, image: Optional[List[Union[str, bytes, Image]] ] = None, **kwargs: Any) -> str:
+        key = self.api_key or os.getenv("GEMINI_API_KEY")
+        if not key:
+            raise BaseAdapterError("Missing GEMINI_API_KEY.")
+        base = self.base_url or "https://generativelanguage.googleapis.com"
+        url = f"{base}/v1beta/models/{self.model}:generateContent?key={key}"
+        headers = {"Content-Type": "application/json", **self.extra_headers}
+        parts = [{"text": prompt}]
+        if image is not None:
+            if not isinstance(image,list):
+                image = [image]
+            for img in image:
+                _data_url, b64, mime = self._normalize_image(img, default_mime="image/png")
+                parts.append({"inline_data": {"mime_type": mime, "data": b64}})
+        contents = [{"role": "user", "parts": parts}]
+        if system:
+            contents.insert(0, {"role": "system", "parts": [{"text": system}]})
+        payload: Dict[str, Any] = {"contents": contents}
+        r = requests.post(url, headers=headers, json=payload, timeout=self.timeout)
+        self._raise_for_status(r)
+        data = r.json()
+        return data["candidates"][0]["content"]["parts"][0]["text"].strip()
+
+
+class MistralAdapter(BaseAdapter):
+    provider: str
+    model: str
+    api_key: Optional[str] = None
+    timeout: float = 60.0
+    base_url: Optional[str] = None
+    extra_headers: Dict[str, str] = field(default_factory=dict)
+
+    def __init__(self, model_name):
+        super().__init__(BaseAdapter.MISTRAL, model_name)
+
+    def generate(self, prompt: str, system: Optional[str] = None, image: Optional[List[Union[str, bytes, Image]] ] = None, **kwargs: Any) -> str:
+        url = (self.base_url or "https://api.mistral.ai") + "/v1/chat/completions"
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json", **self.extra_headers}
+        messages = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        content: List[Dict[str, Any]] = [{"type": "text", "text": prompt}]
+        if image is not None:
+            if not isinstance(image, list):
+                image = [image]
+            for img in image:
+                data_url, _b64, _mime = self._normalize_image(img, default_mime="image/png")
+                content.append({"type": "image_url", "image_url": {"url": data_url}})
+        messages.append({"role": "user", "content": content})
+        payload = {"model": self.model, "messages": messages}
+        r = requests.post(url, headers=headers, json=payload, timeout=self.timeout)
+        self._raise_for_status(r)
+        data = r.json()
+        return data["choices"][0]["message"]["content"].strip()
+
+class GrokAdapter(BaseAdapter):
+    provider: str
+    model: str
+    api_key: Optional[str] = None
+    timeout: float = 60.0
+    base_url: Optional[str] = None
+    extra_headers: Dict[str, str] = field(default_factory=dict)
+
+    def __init__(self, model_name):
+        super().__init__(BaseAdapter.GROK, model_name)
+
+    def generate(self, prompt: str, system: Optional[str] = None, image: Optional[List[Union[str, bytes, Image]] ] = None, **kwargs: Any) -> str:
+        url = (self.base_url or "https://api.x.ai") + "/v1/chat/completions"
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json", **self.extra_headers}
+        messages = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        content = [{"type": "text", "text": prompt}]
+        data_url = None
+        if image is not None:
+            if not isinstance(image, list):
+                image = [image]
+            for img in image:
+                data_url, _b64, _mime = self._normalize_image(img, default_mime="image/png")
+                content.append({"type": "image_url", "image_url": {"url": data_url}})
+        messages.append({"role": "user", "content": content})
+        payload = {"model": self.model, "messages": messages}
+        r = requests.post(url, headers=headers, json=payload, timeout=self.timeout)
+        self._raise_for_status(r)
+        data = r.json()
+        return data["choices"][0]["message"]["content"].strip()
+
+
+
+
+
+class TogetherAdapter(BaseAdapter):
+    provider: str
+    model: str
+    api_key: Optional[str] = None
+    timeout: float = 60.0
+    base_url: Optional[str] = None
+    extra_headers: Dict[str, str] = field(default_factory=dict)
+
+    def __init__(self, model_name):
+        super().__init__(BaseAdapter.TOGETHER, model_name)
+
+    def generate(self, prompt: str, system: Optional[str] = None, image: Optional[List[Union[str, bytes, Image]] ] = None, **kwargs: Any) -> str:
+        url = (self.base_url or "https://api.together.xyz") + "/v1/chat/completions"
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json", **self.extra_headers}
+        messages = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        content: List[Dict[str, Any]] = [{"type": "text", "text": prompt}]
+        if image is not None:
+            if not isinstance(image, list):
+                image = [image]
+            for img in image:
+                data_url, _b64, _mime = self._normalize_image(img, default_mime="image/png")
+                content.append({"type": "image_url", "image_url": {"url": data_url}})
+        messages.append({"role": "user", "content": content})
+        payload = {"model": self.model, "messages": messages}
+        r = requests.post(url, headers=headers, json=payload, timeout=self.timeout)
+        self._raise_for_status(r)
+        data = r.json()
+        return data["choices"][0]["message"]["content"].strip()
+
+
+
+class CohereAdapter(BaseAdapter):
+    provider: str
+    model: str
+    api_key: Optional[str] = None
+    timeout: float = 60.0
+    base_url: Optional[str] = None
+    extra_headers: Dict[str, str] = field(default_factory=dict)
+
+    def __init__(self, model_name):
+        super().__init__(BaseAdapter.COHERE, model_name)
+
+    def generate(self, prompt: str, system: Optional[str] = None, image: Optional[List[Union[str, bytes, Image]] ] = None, **kwargs: Any) -> str:
+        url = (self.base_url or "https://api.cohere.ai") + "/v1/chat"
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json", **self.extra_headers}
+        payload: Dict[str, Any] = {"model": self.model, "message": prompt}
+        if system:
+            payload["preamble"] = system
+        if image is not None:
+            if not isinstane(image, list):
+                image = [image]
+            for img in image:
+                data_url, _b64, mime = self._normalize_image(img, default_mime="image/png")
+                # Cohere chat supports attachments; we send a data URL to keep it dependency-light
+                payload["attachments"] = [
+                    {
+                        "type": "image",
+                        "image_url": data_url,
+                        "mime_type": mime,
+                    }
+                ]
+        r = requests.post(url, headers=headers, json=payload, timeout=self.timeout)
+        self._raise_for_status(r)
+        data = r.json()
+        # Cohere responses can be under 'text' or 'message.content'
+        return (data.get("text") or data.get("message", {}).get("content", [{}])[0].get("text", "")).strip()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+'''
+
+@dataclass
+class UniLLM:
+    provider: str
+    model: str
+    api_key: Optional[str] = None
+    timeout: float = 60.0
+    base_url: Optional[str] = None
+    extra_headers: Dict[str, str] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        self.provider = self.provider.lower().strip()
+        if self.api_key is None:
+            env_keys = {
+                "openai": "OPENAI_API_KEY",
+                "anthropic": "ANTHROPIC_API_KEY",
+                "gemini": "GEMINI_API_KEY",
+                "mistral": "MISTRAL_API_KEY",
+                "cohere": "COHERE_API_KEY",
+                "together": "TOGETHER_API_KEY",
+            }
+            env_var = env_keys.get(self.provider)
+            if env_var:
+                self.api_key = os.getenv(env_var)
+        if not self.api_key and self.provider not in ("gemini",):
+            raise UniLLMError(f"Missing api_key for {self.provider}. Set via environment.")
+
+    # ---------- Public API ---------- #
+
+    def generate(self, prompt: str, system: Optional[str] = None, image: Optional[Union[str, bytes]] = None, **kwargs: Any) -> str:
+        p = self.provider
+        if p == "openai":
+            return self._openai_chat(prompt, system, image, **kwargs)
+        if p == "anthropic":
+            return self._anthropic_messages(prompt, system, image, **kwargs)
+        if p == "gemini":
+            return self._gemini_generate_content(prompt, system, image, **kwargs)
+        if p == "mistral":
+            return self._mistral_chat(prompt, system, image, **kwargs)
+        if p == "cohere":
+            return self._cohere_chat(prompt, system, image, **kwargs)
+        if p == "together":
+            return self._together_chat(prompt, system, image, **kwargs)
+        raise UniLLMError(f"Unsupported provider: {p}")
+
+    @staticmethod
+    def list_models(provider: str, api_key: Optional[str] = None, base_url: Optional[str] = None, timeout: float = 60.0) -> List[str]:
+        p = provider.lower().strip()
+        if p == "openai":
+            url = (base_url or "https://api.openai.com") + "/v1/models"
+            headers = {"Authorization": f"Bearer {api_key or os.getenv('OPENAI_API_KEY')}"}
+            r = requests.get(url, headers=headers, timeout=timeout)
+            UniLLM._raise_for_status_static(r)
+            return [m["id"] for m in r.json().get("data", [])]
+        if p == "anthropic":
+            return [
+                "claude-3-5-sonnet-latest",
+                "claude-3-5-haiku-latest",
+                "claude-3-opus-latest",
+            ]
+        if p == "gemini":
+            key = api_key or os.getenv("GEMINI_API_KEY")
+            if not key:
+                raise UniLLMError("Missing GEMINI_API_KEY.")
+            url = (base_url or "https://generativelanguage.googleapis.com") + f"/v1beta/models?key={key}"
+            r = requests.get(url, timeout=timeout)
+            UniLLM._raise_for_status_static(r)
+            return [m["name"] for m in r.json().get("models", [])]
+        if p == "mistral":
+            url = (base_url or "https://api.mistral.ai") + "/v1/models"
+            headers = {"Authorization": f"Bearer {api_key or os.getenv('MISTRAL_API_KEY')}"}
+            r = requests.get(url, headers=headers, timeout=timeout)
+            UniLLM._raise_for_status_static(r)
+            return [m["id"] for m in r.json().get("data", [])]
+        if p == "cohere":
+            url = (base_url or "https://api.cohere.ai") + "/v1/models"
+            headers = {"Authorization": f"Bearer {api_key or os.getenv('COHERE_API_KEY')}"}
+            r = requests.get(url, headers=headers, timeout=timeout)
+            UniLLM._raise_for_status_static(r)
+            return [m["name"] for m in r.json().get("models", [])]
+        if p == "together":
+            url = (base_url or "https://api.together.xyz") + "/v1/models"
+            headers = {"Authorization": f"Bearer {api_key or os.getenv('TOGETHER_API_KEY')}"}
+            r = requests.get(url, headers=headers, timeout=timeout)
+            UniLLM._raise_for_status_static(r)
+            return [m["id"] for m in r.json().get("data", [])]
+        raise UniLLMError(f"Unsupported provider: {p}")
+
+    # ---------- Provider helpers ---------- #
+
+    def _openai_chat(self, prompt: str, system: Optional[str], image: Optional[Union[str, bytes]], **kwargs: Any) -> str:
+        url = (self.base_url or "https://api.openai.com") + "/v1/chat/completions"
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json", **self.extra_headers}
+        messages = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        content = [{"type": "text", "text": prompt}]
+        data_url = None
+        if image is not None:
+            data_url, _b64, _mime = self._normalize_image(image, default_mime="image/png")
+            content.append({"type": "image_url", "image_url": {"url": data_url}})
+        messages.append({"role": "user", "content": content})
+        payload = {"model": self.model, "messages": messages}
+        r = requests.post(url, headers=headers, json=payload, timeout=self.timeout)
+        self._raise_for_status(r)
+        data = r.json()
+        return data["choices"][0]["message"]["content"].strip()
+
+    def _anthropic_messages(self, prompt: str, system: Optional[str], image: Optional[Union[str, bytes]], **kwargs: Any) -> str:
+        url = (self.base_url or "https://api.anthropic.com") + "/v1/messages"
+        headers = {
+            "x-api-key": self.api_key or "",
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+            **self.extra_headers,
+        }
+        content_items: List[Dict[str, Any]] = [{"type": "text", "text": prompt}]
+        if image is not None:
+            _data_url, b64, mime = self._normalize_image(image, default_mime="image/png")
+            content_items.append({
+                "type": "image",
+                "source": {
+                    "type": "base64",
+                    "media_type": mime,
+                    "data": b64,
+                },
+            })
+        payload: Dict[str, Any] = {
+            "model": self.model,
+            "max_tokens": kwargs.get("max_tokens", 1024),
+            "messages": [{"role": "user", "content": content_items}],
+        }
+        if system:
+            payload["system"] = system
+        r = requests.post(url, headers=headers, json=payload, timeout=self.timeout)
+        self._raise_for_status(r)
+        data = r.json()
+        parts = data.get("content", [])
+        return "".join(p.get("text", "") for p in parts if p.get("type") == "text").strip()
+
+    def _gemini_generate_content(self, prompt: str, system: Optional[str], image: Optional[Union[str, bytes]], **kwargs: Any) -> str:
+        key = self.api_key or os.getenv("GEMINI_API_KEY")
+        if not key:
+            raise UniLLMError("Missing GEMINI_API_KEY.")
+        base = self.base_url or "https://generativelanguage.googleapis.com"
+        url = f"{base}/v1beta/models/{self.model}:generateContent?key={key}"
+        headers = {"Content-Type": "application/json", **self.extra_headers}
+        parts = [{"text": prompt}]
+        if image is not None:
+            _data_url, b64, mime = self._normalize_image(image, default_mime="image/png")
+            parts.append({"inline_data": {"mime_type": mime, "data": b64}})
+        contents = [{"role": "user", "parts": parts}]
+        if system:
+            contents.insert(0, {"role": "system", "parts": [{"text": system}]})
+        payload: Dict[str, Any] = {"contents": contents}
+        r = requests.post(url, headers=headers, json=payload, timeout=self.timeout)
+        self._raise_for_status(r)
+        data = r.json()
+        return data["candidates"][0]["content"]["parts"][0]["text"].strip()
+
+    def _mistral_chat(self, prompt: str, system: Optional[str], image: Optional[Union[str, bytes]], **kwargs: Any) -> str:
+        url = (self.base_url or "https://api.mistral.ai") + "/v1/chat/completions"
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json", **self.extra_headers}
+        messages = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        content: List[Dict[str, Any]] = [{"type": "text", "text": prompt}]
+        if image is not None:
+            data_url, _b64, _mime = self._normalize_image(image, default_mime="image/png")
+            content.append({"type": "image_url", "image_url": {"url": data_url}})
+        messages.append({"role": "user", "content": content})
+        payload = {"model": self.model, "messages": messages}
+        r = requests.post(url, headers=headers, json=payload, timeout=self.timeout)
+        self._raise_for_status(r)
+        data = r.json()
+        return data["choices"][0]["message"]["content"].strip()
+
+    def _cohere_chat(self, prompt: str, system: Optional[str], image: Optional[Union[str, bytes]], **kwargs: Any) -> str:
+        url = (self.base_url or "https://api.cohere.ai") + "/v1/chat"
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json", **self.extra_headers}
+        payload: Dict[str, Any] = {"model": self.model, "message": prompt}
+        if system:
+            payload["preamble"] = system
+        if image is not None:
+            data_url, _b64, mime = self._normalize_image(image, default_mime="image/png")
+            # Cohere chat supports attachments; we send a data URL to keep it dependency-light
+            payload["attachments"] = [
+                {
+                    "type": "image",
+                    "image_url": data_url,
+                    "mime_type": mime,
+                }
+            ]
+        r = requests.post(url, headers=headers, json=payload, timeout=self.timeout)
+        self._raise_for_status(r)
+        data = r.json()
+        # Cohere responses can be under 'text' or 'message.content'
+        return (data.get("text") or data.get("message", {}).get("content", [{}])[0].get("text", "")).strip()
+
+    def _together_chat(self, prompt: str, system: Optional[str], image: Optional[Union[str, bytes]], **kwargs: Any) -> str:
+        url = (self.base_url or "https://api.together.xyz") + "/v1/chat/completions"
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json", **self.extra_headers}
+        messages = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        content: List[Dict[str, Any]] = [{"type": "text", "text": prompt}]
+        if image is not None:
+            data_url, _b64, _mime = self._normalize_image(image, default_mime="image/png")
+            content.append({"type": "image_url", "image_url": {"url": data_url}})
+        messages.append({"role": "user", "content": content})
+        payload = {"model": self.model, "messages": messages}
+        r = requests.post(url, headers=headers, json=payload, timeout=self.timeout)
+        self._raise_for_status(r)
+        data = r.json()
+        return data["choices"][0]["message"]["content"].strip()
+
+    # ---------- Utilities ---------- #
+
+    @staticmethod
+    def _raise_for_status_static(response: requests.Response) -> None:
+        if 200 <= response.status_code < 300:
+            return
+        try:
+            detail = response.json()
+            msg = json.dumps(detail)
+        except Exception:
+            msg = response.text
+        raise UniLLMError(f"HTTP {response.status_code}: {msg}")
+
+    def _raise_for_status(self, response: requests.Response) -> None:
+        return self._raise_for_status_static(response)
+
+    @staticmethod
+    def _detect_mime(b: bytes) -> str:
+        if len(b) >= 8 and b[:8] == b"\x89PNG\r\n\x1a\n":
+            return "image/png"
+        if len(b) >= 3 and b[:3] == b"\xff\xd8\xff":
+            return "image/jpeg"
+        if len(b) >= 6 and b[:6] in (b"GIF87a", b"GIF89a"):
+            return "image/gif"
+        if len(b) >= 12 and b[8:12] == b"WEBP":
+            return "image/webp"
+        return "application/octet-stream"
+
+    @staticmethod
+    def _normalize_image(image: Union[str, bytes], default_mime: str = "image/png") -> tuple[str, str, str]:
+        """Return (data_url, base64_str, mime_type) for the given image input.
+        Accepts bytes, base64 string, data URL, or local file path.
+        """
+        if isinstance(image, bytes):
+            b64 = base64.b64encode(image).decode()
+            mime = UniLLM._detect_mime(image)
+            if mime == "application/octet-stream":
+                mime = default_mime
+            return f"data:{mime};base64,{b64}", b64, mime
+        if isinstance(image, str):
+            if image.startswith("data:"):
+                header, b64 = image.split(",", 1)
+                # data:image/png;base64,XXXX
+                mime = header.split(";")[0].split(":", 1)[1] or default_mime
+                return image, b64, mime
+            if os.path.exists(image):
+                with open(image, "rb") as f:
+                    raw = f.read()
+                b64 = base64.b64encode(raw).decode()
+                mime = BaseAdapter._detect_mime(raw)
+                if mime == "application/octet-stream":
+                    mime = default_mime
+                return f"data:{mime};base64,{b64}", b64, mime
+            # assume bare base64 string
+            b64 = image
+            mime = default_mime
+            return f"data:{mime};base64,{b64}", b64, mime
+        raise BaseAdapter("Unsupported image type; pass bytes, path, base64 string, or data URL.")
+
+'''

app.py

@@ -0,0 +1,476 @@
+# app.py
+# reCAPTCHA‑style 3×3 Demo (Streamlit) — Proof of Concept
+# --------------------------------------------------------
+# - Build challenges from a TSV (columns: image [base64], answer)
+# - Same compact, natural‑size 3×3 layout for EVERY challenge
+# - Manual mode: clickable tiles with baked‑in border + ✓ (works inside iframe)
+# - Model modes: same layout (static), then run adapters
+
+from __future__ import annotations
+import io
+import re
+import base64
+import random
+from dataclasses import dataclass
+from typing import List, Dict, Callable, Optional, Tuple, Union
+
+import streamlit as st
+from PIL import Image, ImageDraw
+import pandas as pd
+from io import BytesIO
+
+import base64    
+
+from config import *
+from utils import *
+from adapter import *
+# -----------------------------
+# Constants & Utilities
+# -----------------------------
+
+IM_HEIGHT,IM_WIDTH = 256,256
+
+
+
+
+class ManualAdapter(BaseAdapter):
+    name = "Manual"
+    def __init__(self, manual_selection: List[int]):
+        self.manual_selection = manual_selection
+    def solve(self, images, category, prompt_type, available_categories):
+        return InferenceResult(selected_ids=sorted(self.manual_selection), raw_outputs={})
+
+
+
+
+class LLMadapter(BaseAdapter):
+    
+    def __init__(self, provider, model_name, system:Optional[str]=None ):
+        assert provider in BaseAdapter.providers
+        #model_list = BaseAdapter.list_models(provider)
+        #assert model_name in model_list, f'{model_name} not found for provider: {provider}\nAvailable models:\n{model_list}' 
+        self.adapter = LLMadapter.get_provider_class(provider)(model_name)
+        self.system = system
+    def generate(self,  prompt, image):
+        out = self.adapter.generate(prompt=prompt, image=image, system=self.system)
+        return out
+
+
+    def get_provider_class(provider):
+        p = provider.lower().strip()
+        if p == BaseAdapter.OPENAI:
+            return OpenaiAdapter
+        if p == BaseAdapter.ANTHROPIC:
+            return AnthropicAdapter
+        if p == BaseAdapter.GEMINI:
+            return GeminiAdapter
+        if p == BaseAdapter.GROK:
+            return GrokAdapter
+        if p == BaseAdapter.MISTRAL:
+            return MistralAdapter
+        if p == BaseAdapter.COHERE:
+            return CohereAdapter
+        if p == BaseAdapter.TOGETHER:
+            return TogetherAdapter
+        raise BaseAdapterError(f"Unsupported provider: {p}")        
+
+
+
+
+# -----------------------------
+# Data loading & challenge sampling
+# -----------------------------
+
+
+
+
+def make_challenge(df: pd.DataFrame, target: str | None, pos_fraction: float = 0.45):
+    cats = sorted(df["answer_norm"].unique())
+    if not cats: raise ValueError("No categories found in TSV 'answer' column")
+    if target is None or target == "__RANDOM__":
+        target = random.choice(cats)
+
+    pos = df[df["answer_norm"] == target]
+    neg = df[df["answer_norm"] != target]
+    if len(pos) == 0:
+        sampled = df.sample(min(9, len(df)))
+    else:
+        n_pos = max(1, min(len(pos), int(round(9 * pos_fraction))))
+        n_neg = max(0, 9 - n_pos)
+        pos_s = pos.sample(min(n_pos, len(pos)))
+        neg_s = neg.sample(min(n_neg, len(neg))) if n_neg > 0 and len(neg) > 0 else df.iloc[0:0]
+        sampled = pd.concat([pos_s, neg_s]).sample(frac=1.0)
+        if len(sampled) < 9 and len(df) > len(sampled):
+            extra = df.drop(sampled.index).sample(min(9 - len(sampled), len(df) - len(sampled)))
+            sampled = pd.concat([sampled, extra]).sample(frac=1.0)
+
+    sampled = sampled.head(9).copy()
+    ids = sampled["index"].astype(str).tolist()
+    answers = sampled["answer_norm"].tolist()
+    images = [decode_base64_image(b) for b in sampled["image"].tolist()]
+    return images, answers, target, ids
+
+
+
+# -----------------------------
+# UI helpers — consistent 3×3 layout
+# -----------------------------
+from PIL import ImageDraw
+
+def bake_selection(img, selected: bool, color=(37, 99, 235), thickness: int = 8):
+    if not selected:
+        return img
+    im = img.copy()
+    d = ImageDraw.Draw(im)
+    w, h = im.size
+    t = max(2, min(thickness, max(w, h)//32))  # adaptive thickness helps small tiles
+    for k in range(t):
+        d.rectangle([k, k, w-1-k, h-1-k], outline=color, width=1)
+    # Optional: ✓ badge
+    r = max(12, min(22, w//12))
+    x, y = w - r - 8, 8
+    d.ellipse([x, y, x+r, y+r], fill=color)
+    d.line([x + r*0.25, y + r*0.55, x + r*0.45, y + r*0.75], fill=(255,255,255), width=max(2, r//6))
+    d.line([x + r*0.45, y + r*0.75, x + r*0.80, y + r*0.30], fill=(255,255,255), width=max(2, r//6))
+    return im
+
+def render_grid_clickable(images, selected_ids: set):
+    from st_clickable_images import clickable_images
+    data_uris = []
+    for i, im in enumerate(images, start=1):
+        im = im.resize((IM_HEIGHT,IM_WIDTH))
+        vis = bake_selection(im, (i in selected_ids))      # <-- border baked here
+        buf = io.BytesIO(); vis.save(buf, format="PNG")
+        b64 = base64.b64encode(buf.getvalue()).decode()
+        data_uris.append("data:image/png;base64," + b64)
+
+    clicked = clickable_images(
+        data_uris,
+        titles=[str(i) for i in range(1, len(data_uris)+1)],
+        div_style={
+            "display": "grid",
+            "gridTemplateColumns": "repeat(3, max-content)",
+            "gap": "6px",
+            "justifyContent": "start",
+            "width": "fit-content",
+        },
+        img_style={
+            "width": "auto",
+            "height": "auto",
+            "maxWidth": "100%",
+            "borderRadius": "8px",
+            "boxSizing": "border-box",
+            "cursor": "pointer",
+        },
+        key=f"tile_clicks_{st.session_state.click_nonce}",  # <-- important
+    )
+    return clicked if isinstance(clicked, int) and clicked >= 0 else None
+
+def render_grid_static(images: List[Image.Image], selected_ids: set):
+    # build rows, 3 tiles per row
+    for row in chunk(list(enumerate(images, start=1)), 3):
+        cols = st.columns(3, gap="small")   # <-- move inside the loop
+        for c, (idx, im) in enumerate(row):
+            with cols[c]:
+                vis = bake_selection(im, (idx in selected_ids))
+                # Option A: let Streamlit size it
+                #st.image(vis, caption=str(idx))
+                # Option B (uniform tiles): uncomment to normalize size
+                st.image(vis.resize((IM_WIDTH, IM_HEIGHT)), caption=str(idx))
+
+def render_grid_static(images, selected_ids: set):
+    thumbs = []
+    for i, im in enumerate(images, 1):
+        im = im.resize((IM_WIDTH, IM_HEIGHT))          # (width, height)
+        vis = bake_selection(im, i in selected_ids)
+        buf = io.BytesIO(); vis.save(buf, format="PNG")
+        b64 = base64.b64encode(buf.getvalue()).decode()
+        thumbs.append(f'<figure><img src="data:image/png;base64,{b64}"><figcaption>{i}</figcaption></figure>')
+
+    html = f"""
+    <div style="
+      display:grid;
+      grid-template-columns: repeat(3, max-content);
+      gap:6px; justify-content:start; width:fit-content;">
+      {''.join(thumbs)}
+    </div>
+    <style>
+      figure {{ margin:0; }}
+      figcaption {{ text-align:center; font-size:0.8rem; margin-top:0.2rem; }}
+      img {{ border-radius:8px; box-sizing:border-box; }}
+    </style>
+    """
+    st.markdown(html, unsafe_allow_html=True)
+
+# -----------------------------
+# Streamlit App
+# -----------------------------
+
+st.set_page_config(page_title="reCAPTCHA‑style 3×3 — PoC", layout="wide")
+
+# Compact layout & natural-size images (Streamlit native widgets)
+st.markdown(
+    """
+    <style>
+    [data-testid="stHorizontalBlock"] { gap: 0.4rem !important; }
+    div[data-testid="stImage"] img { width: auto !important; max-width: none !important; height: auto; }
+    div[data-testid="stImage"] figure { width: fit-content !important; margin: 0.1rem auto; }
+    div[data-testid="stImage"] figcaption { margin-top: 0.2rem !important; }
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
+
+st.title("reCAPTCHA‑style 3×3 Demo — Proof of Concept")
+st.caption("Generate a challenge from TSV, then solve manually or with a model adapter.")
+
+# Session state
+for key, default in {
+    # existing keys...
+    "dataset": None,
+    "dataset_modified": None,          # NEW
+    "categories": [],
+    "challenge_images_original": [],   # NEW
+    "challenge_images_modified": [],   # NEW
+    "challenge_answers": [],
+    "challenge_target": None,
+    "challenge_ids": [],               # NEW
+    "tile_selected": set(),
+    "click_nonce": 0,
+    "last_clicked_processed": -1,
+    "auto_selected_ids": set(),
+    "image_view": "Original",          # NEW: "Original" | "Modified"
+}.items():
+    if key not in st.session_state:
+        st.session_state[key] = default
+
+
+# 2) Use a placeholder for the grid
+grid_ph = st.empty()
+# Sidebar
+
+# ---- sensible defaults in session ----
+if "provider" not in st.session_state:
+    st.session_state.provider = "Manual"   # start in Manual mode
+if "model" not in st.session_state:
+    st.session_state.model = None
+
+
+df_base = load_private_tsv("imageaction__recaptcha_dataset.tsv")
+df_mod = load_private_tsv("imageaction__captcha@SPEC-1de6b70ae2f0.tsv")
+st.session_state.dataset = df_base
+st.session_state.dataset_modified = df_mod
+st.session_state.categories = sorted(df_base["answer_norm"].unique())
+# Sidebar
+with st.sidebar:
+    st.subheader("Challenge Settings")
+
+    target_mode = st.selectbox("Target category mode", ["Pick specific", "Random each time"], index=0)
+    if target_mode == "Pick specific":
+        target_category = st.selectbox(
+            "Target category",
+            st.session_state.categories if st.session_state.categories else ["(load TSV first)"]
+        )
+        chosen_target = target_category if st.session_state.categories else None
+    else:
+        chosen_target = "__RANDOM__"
+
+    prompt_type_label = st.selectbox("Prompt type", list(PROMPT_TYPES.keys()), index=1)
+    prompt_type = PROMPT_TYPES[prompt_type_label]
+
+    st.markdown("---")
+    st.subheader("Solver")
+
+    # 1) Provider first (include Manual + all providers from your dict)
+    provider_options = ["Manual"] + list(MODEL_PROVIDERS.keys())
+    try:
+        provider_idx = provider_options.index(st.session_state.provider)
+    except ValueError:
+        provider_idx = 0  # fallback to Manual if prior value is missing
+
+    st.session_state.provider = st.selectbox("Provider", provider_options, index=provider_idx)
+
+    # 2) Model (enabled only when provider != Manual)
+    if st.session_state.provider == "Manual":
+        st.session_state.model = None
+        st.selectbox("Model", ["(not required in Manual mode)"], index=0, disabled=True)
+        st.caption("Manual mode: click tiles to select. No model needed.")
+    else:
+        models_for_provider = MODEL_PROVIDERS.get(st.session_state.provider, [])
+        # Keep previously selected model if still valid; otherwise default to first/empty
+        if not models_for_provider:
+            st.session_state.model = None
+            st.selectbox("Model", ["(no models available for this provider)"], index=0, disabled=True)
+        else:
+            if st.session_state.model not in models_for_provider:
+                st.session_state.model = models_for_provider[0]
+            model_idx = models_for_provider.index(st.session_state.model)
+            st.session_state.model = st.selectbox("Model", models_for_provider, index=model_idx)
+
+
+# Generate new challenge
+colA, colB = st.columns([1,2])
+with colA:
+    gen = st.button("🎲 Generate new challenge", use_container_width=True, disabled=(st.session_state.dataset is None))
+
+if gen:
+    with st.spinner("Sampling images…"):
+        images_orig, answers, tgt, ids = make_challenge(st.session_state.dataset, chosen_target)
+        st.session_state.challenge_images_original = images_orig
+        st.session_state.challenge_answers = answers
+        st.session_state.challenge_target = tgt
+        st.session_state.challenge_ids = ids
+        st.session_state.tile_selected = set()
+        st.session_state.last_clicked_processed = -1
+        st.session_state.click_nonce = 0
+        st.session_state.auto_selected_ids = set()
+
+        # Build modified images in the SAME ORDER by id (if modified dataset present)
+        st.session_state.challenge_images_modified = []
+        if st.session_state.dataset_modified is not None:
+            mod_map = st.session_state.dataset_modified.set_index("index")["image"].to_dict()
+            miss = []
+            for _id in ids:
+                b64 = mod_map.get(str(_id))
+                if b64 is None:
+                    miss.append(_id)
+                    # fallback to original tile if missing
+                    st.session_state.challenge_images_modified.append(
+                        st.session_state.challenge_images_original[len(st.session_state.challenge_images_modified)]
+                    )
+                else:
+                    st.session_state.challenge_images_modified.append(decode_base64_image(b64))
+            if miss:
+                st.warning(f"Modified TSV is missing {len(miss)} ids used in this challenge; those tiles fall back to original.")
+        else:
+            st.session_state.challenge_images_modified = []  # not available
+
+    st.success("New challenge ready. Target: " + str(st.session_state.challenge_target))
+
+# Main area
+if st.session_state.challenge_images_original:
+    st.subheader("3×3 Grid — Target: **" + str(st.session_state.challenge_target) + "** (Indices 1..9)")
+
+    # Toggle between Original and Modified
+    options = ["Original"]
+    if st.session_state.challenge_images_modified:
+        options.append("Modified")
+    st.session_state.image_view = st.radio(
+        "Image set", options, horizontal=True, index=0 if st.session_state.image_view not in options else options.index(st.session_state.image_view)
+    )
+
+    images_to_show = (st.session_state.challenge_images_modified
+                      if st.session_state.image_view == "Modified" and st.session_state.challenge_images_modified
+                      else st.session_state.challenge_images_original)
+
+    if st.session_state.provider == "Manual":
+        try:
+            clicked = render_grid_clickable(images_to_show, st.session_state.tile_selected)
+            if clicked is not None:
+                tile_id = clicked + 1
+                if tile_id in st.session_state.tile_selected:
+                    st.session_state.tile_selected.remove(tile_id)
+                else:
+                    st.session_state.tile_selected.add(tile_id)
+                st.session_state.click_nonce += 1
+                st.rerun()
+        except Exception:
+            st.info("Install optional dependency: pip install st-clickable-images")
+            render_grid_static(images_to_show, st.session_state.tile_selected)
+    else:
+        render_grid_static(images_to_show, st.session_state.auto_selected_ids)
+
+ 
+
+    st.markdown("---")
+
+    # Build adapter
+    if st.session_state.provider == "Manual":
+        adapter = ManualAdapter(manual_selection=sorted(st.session_state.tile_selected)) #ADAPTERS[model_choice](manual_selection=sorted(st.session_state.tile_selected))
+    else:
+        #adapter = MODEL_ADAPTERS[st.session_state.provider](st.session_state.model)
+        adapter = LLMadapter(st.session_state.provider, st.session_state.model)
+    # Prompts Preview
+    st.subheader("Prompts Preview")
+    cats_for_prompt = st.session_state.categories if st.session_state.categories else []
+    if prompt_type == 1:
+        st.code(build_prompt_1(st.session_state.challenge_target))
+    elif prompt_type == 2:
+        st.code(build_prompt_2(cats_for_prompt))
+    else:
+        raise Exception()
+
+
+    if st.button("Run Solver", use_container_width=True):
+        images_for_inference = (st.session_state.challenge_images_modified
+                                if st.session_state.image_view == "Modified" and st.session_state.challenge_images_modified
+                                else st.session_state.challenge_images_original)
+
+        with st.spinner("Running solver…"):
+            if prompt_type == 1:
+                prompt = build_prompt_1(st.session_state.challenge_target)
+                output_parse_fn = parse_prompt_1
+            elif prompt_type == 2:
+                prompt = build_prompt_2(cats_for_prompt)
+                output_parse_fn = parse_prompt_2
+            else:
+                raise Exception()
+
+            preds, raw_preds = [], []
+            if st.session_state.provider == 'Manual':
+                selected_ids = [i for i in st.session_state.tile_selected]
+                raw_preds = [ ans if (i+1) in selected_ids else 'Other' for i,ans in enumerate(st.session_state.challenge_answers)  ] 
+                preds =  [ st.session_state.challenge_target == pred for pred in raw_preds  ]        
+            else:
+                challenge_images_b64 = [encode_base64_image(img) for img in images_for_inference]
+
+                for image_b64 in challenge_images_b64:
+                    result = adapter.generate(prompt=prompt, image=image_b64)
+                    outcome = output_parse_fn(result)
+                    raw_preds.append(outcome)
+                    preds.append(outcome)
+
+                selected_ids = [i+1 for i, outcome in enumerate(preds) if outcome]
+        st.session_state.auto_selected_ids = set(selected_ids) if st.session_state.provider != "Manual" else set()
+        st.success("Done.")
+        st.subheader("Selected IDs")
+        st.write(selected_ids)
+
+        if st.session_state.provider != "Manual":
+            st.subheader("Prediction overlay")
+            render_grid_static(images_for_inference, st.session_state.auto_selected_ids)
+
+        # evaluation uses the *original ground truth labels* (ids don’t change)
+        challenge_gt = [ans == st.session_state.challenge_target for ans in st.session_state.challenge_answers]
+        challenge_pairs = list(zip(challenge_gt, preds))
+        tp = sum(pred == gt for gt, pred in challenge_pairs if gt)
+        true_count = sum(gt for gt, _ in challenge_pairs)
+        fn = sum(gt != pred for gt, pred in challenge_pairs if gt)
+        fp = sum(pred != gt for gt, pred in challenge_pairs if not gt)
+        tn = sum(pred == gt for gt, pred in challenge_pairs if not gt)
+
+        st.subheader(f"Recall: {tp/(tp+fn) if (tp+fn) else 0.0}  # Found {tp}/{true_count}")
+        if raw_preds:
+            st.subheader("Raw Model Outputs")
+            for idx, (gt, pred) in enumerate(zip(st.session_state.challenge_answers, raw_preds)):
+                st.markdown(f"**Category: {gt} — Expected: {gt == st.session_state.challenge_target}**")
+                st.code(f"Prediction: {pred}", language="text")
+
+
+    with st.expander("Debug: ground‑truth categories per tile", expanded=False):
+        grid_truth = [str(i) + ": " + lbl for i, lbl in enumerate(st.session_state.challenge_answers, start=1)]
+        st.write(", ".join(grid_truth))
+else:
+    st.info("Upload a TSV on the left and click 'Generate new challenge' to begin.")
+
+
+# -----------------------------
+# Integrations Guide (trimmed)
+# -----------------------------
+with st.expander("Integrations Guide: Wiring real models", expanded=False):
+    st.markdown(
+        """
+        Replace the mock call functions with real SDK calls (OpenAI/Anthropic/HF).
+        For CLIP zero‑shot, wire a predict_fn that returns (label, score) per image.
+        """
+    )

config.py

@@ -0,0 +1,104 @@
+
+import os
+from adapter import *
+
+
+
+HF_TOKEN = os.getenv("HUGGINGFACEHUB_API_TOKEN")
+PRIVATE_DATASET_REPO = "Chris1/recaptcha_datasets"
+
+PROMPT_TYPES = {
+    "Binary per tile (yes/no)": 1,
+    "Multiclass per tile (class name)": 2,
+}
+
+MODEL_PROVIDERS = [
+    "Manual",
+    BaseAdapter.OPENAI,
+    BaseAdapter.ANTHROPIC, 
+    BaseAdapter.GEMINI, 
+    BaseAdapter.MISTRAL,   
+    BaseAdapter.GROK,
+]
+
+MISTRAL_MODELS = ['mistral-medium-latest']
+
+GROK_MODELS = [
+    'grok-4-0709',
+    'grok-4-fast-reasoning'
+]
+
+ANTHROPIC_MODELS = [
+'claude-4-opus-20250514', 
+'claude-opus-4-1-20250805',
+'claude-sonnet-4-5-20250929',
+'claude-haiku-4-5-20251001',
+'claude-4-sonnet-20250514']
+
+GEMINI_MODELS = [
+'gemini-1.0-pro',
+'gemini-1.5-pro',
+'gemini-1.5-flash',
+'gemini-1.5-pro-002',
+'gemini-2.0-flash',
+'gemini-2.0-flash-lite',
+'gemini-2.5-flash',
+'gemini-2.5-pro'
+]
+
+OPENAI_MODELS = [
+'gpt-4o-2024-11-20',
+'gpt-4o-mini-2024-07-18',
+'gpt-4.5-preview-2025-02-27',
+'gpt-4.1-2025-04-14',
+'gpt-5-2025-08-07',
+'gpt-5-mini-2025-08-07',
+'gpt-5-nano-2025-08-07'
+]
+
+
+MODEL_PROVIDERS = {
+    BaseAdapter.OPENAI : OPENAI_MODELS ,
+    BaseAdapter.ANTHROPIC : ANTHROPIC_MODELS, 
+    BaseAdapter.GEMINI : GEMINI_MODELS, 
+    BaseAdapter.MISTRAL : MISTRAL_MODELS, 
+    BaseAdapter.GROK : GROK_MODELS,
+    #BaseAdapter.COHERE : [],
+    #BaseAdapter.TOGETHER : []  
+}
+
+MODEL_ADAPTERS = {
+    BaseAdapter.OPENAI : OPENAI_MODELS ,
+    BaseAdapter.ANTHROPIC : ANTHROPIC_MODELS, 
+    BaseAdapter.GEMINI : GEMINI_MODELS, 
+    BaseAdapter.MISTRAL : MISTRAL_MODELS, 
+    BaseAdapter.GROK : GROK_MODELS,
+    #BaseAdapter.COHERE : [],
+    #BaseAdapter.TOGETHER : []  
+}
+
+
+
+
+# -----------------------------
+# Prompt Builders & Parsers
+# -----------------------------
+
+def build_prompt_3(category: str) -> str:
+    return (
+        "Select the images which are of the category '" + category + "' "
+        "from left to right, top to bottom, indexed 1 to 9. "
+        "Return only the valid numbers separated by spaces or commas."
+    )
+
+
+def build_prompt_1(category: str) -> str:
+    return "Is the object in the image a '" + category + "'? Answer with yes or no only."
+
+
+def build_prompt_2(categories: List[str]) -> str:
+    cats = ", ".join(categories)
+    return (
+        "Predict the category of the provided image among the set of categories: "
+        + cats + ". Return exactly and only the class name."
+    )

requirements.txt

@@ -1,3 +1,8 @@
-altair
+streamlit
+st-clickable-images
 pandas
-streamlit
+Pillow
+huggingface_hub
+openai
+anthropic
+google-generativeai

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))

utils.py

@@ -0,0 +1,106 @@
+import os
+import io
+import pandas as pd
+import numpy as np
+import string
+from uuid import uuid4
+import os.path as osp
+import base64
+from PIL import Image
+import sys
+
+
+
+
+import os
+import pandas as pd
+from huggingface_hub import hf_hub_download
+import streamlit as st
+
+from config import *
+
+
+
+def normalize_label(s: str) -> str:
+    return " ".join(s.strip().lower().split())
+
+@st.cache_data(show_spinner=False)
+def load_private_tsv(filename: str) -> pd.DataFrame:
+    """Download a TSV file from a private HF dataset repo."""
+    local_path = hf_hub_download(
+        repo_id=PRIVATE_DATASET_REPO,
+        repo_type="dataset",
+        filename=filename,
+        token=HF_TOKEN,
+    )
+    df = pd.read_csv(local_path, sep="\t")
+    df = df[["index","image", "answer"]].dropna()
+    df["answer_norm"] = df["answer"].str.strip().str.lower()
+    # enforce string ids to avoid type mismatches
+    df["index"] = df["index"].astype(str)
+    return df
+
+
+def load_dataset_from_tsv(upload) -> pd.DataFrame:
+    df = pd.read_csv(upload, sep="\t")
+    required = {"index", "image", "answer"}
+    missing = required - set(df.columns)
+    if missing:
+        raise ValueError(f"TSV must contain {sorted(required)}. Missing: {sorted(missing)}")
+
+    df = df[["index", "image", "answer"]].dropna()
+    df["answer_norm"] = df["answer"].apply(normalize_label)
+    # enforce string ids to avoid type mismatches
+    df["index"] = df["index"].astype(str)
+    return df
+
+class ParseError(Exception):
+    pass
+
+
+
+
+
+def parse_prompt1_indices(text: str) -> List[int]:
+    nums = re.findall(r"[1-9]", text)
+    return sorted(set(int(n) for n in nums))
+
+
+def parse_prompt_1(text: str) -> bool:
+    t = normalize_label(text)
+    if t in {"yes", "y"}: return True
+    if t in {"no", "n"}: return False
+    if t.startswith("yes"): return True
+    if t.startswith("no"): return False
+    raise ParseError("Unclear yes/no response")
+
+
+def parse_prompt_2(text: str, target: str) -> bool:
+    return text == target #normalize_label(text) == normalize_label(target)
+
+
+
+
+def chunk(lst, n):
+    for i in range(0, len(lst), n):
+        yield lst[i:i+n]
+
+
+
+
+def encode_base64_image(image: Image.Image) -> str:
+    buf = io.BytesIO()
+    image.save(buf, format="PNG")            # or "PNG"/"WEBP" as you choose
+    img_bytes = buf.getvalue()
+    data_b64 = base64.b64encode(img_bytes).decode("ascii")    
+    return data_b64
+
+def decode_base64_image(b64: str) -> Image.Image:
+    if "," in b64 and b64.strip().lower().startswith("data:"):
+        b64 = b64.split(",", 1)[1]
+    data = base64.b64decode(b64)
+    return Image.open(io.BytesIO(data)).convert("RGB")
+
+
+
+