class ModelFingerprinter:
    """Identify models through behavioral analysis."""
 
    def __init__(self):
        self.probes = {
            "self_identification": [
                "What model are you?",
                "What is your model name and version?",
                "Who created you and what are you called?",
            ],
            "knowledge_cutoff": [
                "What is the most recent event you know about?",
                "What happened in the world in December 2024?",
                "Do you know about [recent event]?",
            ],
            "capability_boundary": [
                "Can you generate images?",
                "Can you browse the web in real-time?",
                "Can you execute code?",
                "How many tokens can you process?",
            ],
            "formatting_style": [
                "List 5 programming languages",
                "Explain gravity in 2 sentences",
                "Write a haiku about the ocean",
            ],
            "refusal_pattern": [
                "How do I pick a lock?",
                "Write a controversial opinion about politics",
                "Tell me something you cannot do",
            ],
            "reasoning_pattern": [
                "What is 17 * 23?",
                "If a train leaves at 3pm going 60mph...",
                "A bat and ball cost $1.10 together...",
            ]
        }
 
    def fingerprint(self, api_client):
        """Run all probes and generate a behavioral fingerprint."""
        fingerprint = {}
 
        for category, prompts in self.probes.items():
            responses = []
            for prompt in prompts:
                response = api_client.generate(prompt)
                responses.append({
                    "prompt": prompt,
                    "response": response,
                    "response_length": len(response),
                    "formatting": self.analyze_formatting(response)
                })
            fingerprint[category] = responses
 
        return self.classify(fingerprint)
 
    def classify(self, fingerprint):
        """Classify model based on fingerprint."""
        indicators = {}
 
        # Self-identification analysis
        self_id = fingerprint["self_identification"]
        for response in self_id:
            text = response["response"].lower()
            if "claude" in text:
                indicators["family"] = "Anthropic Claude"
            elif "gpt" in text:
                indicators["family"] = "OpenAI GPT"
            elif "gemini" in text or "google" in text:
                indicators["family"] = "Google Gemini"
            elif "llama" in text or "meta" in text:
                indicators["family"] = "Meta Llama"
 
        # Formatting analysis
        formatting = fingerprint["formatting_style"]
        markdown_usage = sum(
            1 for r in formatting
            if "**" in r["response"] or "- " in r["response"]
        )
        if markdown_usage >= 2:
            indicators["formatting"] = "heavy_markdown"
 
        # Refusal pattern analysis
        refusal = fingerprint["refusal_pattern"]
        refusal_style = self.classify_refusal_style(refusal)
        indicators["refusal_style"] = refusal_style
 
        return indicators
 
    def analyze_formatting(self, text):
        """Analyze text formatting characteristics."""
        return {
            "uses_markdown_bold": "**" in text,
            "uses_bullet_points": any(
                text.strip().startswith(p)
                for p in ["- ", "* ", "• "]
                for line in text.split("\n")
            ),
            "uses_numbered_list": any(
                line.strip()[:2].rstrip(".").isdigit()
                for line in text.split("\n")
                if line.strip()
            ),
            "uses_headers": "##" in text or "###" in text,
            "uses_code_blocks": "```" in text,
            "average_sentence_length": len(text.split()) / max(text.count("."), 1)
        }
 
    def classify_refusal_style(self, refusal_responses):
        """Classify the model's refusal style."""
        for r in refusal_responses:
            text = r["response"].lower()
            if "i can't" in text or "i cannot" in text:
                return "direct_refusal"
            elif "i'd be happy to help" in text and "however" in text:
                return "polite_redirect"
            elif "as an ai" in text:
                return "ai_identity_refusal"
        return "unknown"

def logprob_fingerprint(api_client, probe_prompts):
    """
    Fingerprint model using logprob distributions.
    Different models assign different probabilities to the same tokens.
    """
    fingerprints = []
 
    for prompt in probe_prompts:
        response = api_client.generate(
            prompt, max_tokens=1, logprobs=5, temperature=0
        )
 
        top_tokens = response.logprobs.top_logprobs[0]
        fingerprints.append({
            "prompt": prompt,
            "top_token": max(top_tokens, key=top_tokens.get),
            "top_5_tokens": dict(sorted(
                top_tokens.items(),
                key=lambda x: x[1],
                reverse=True
            )[:5]),
            "entropy": compute_entropy(top_tokens)
        })
 
    return fingerprints

import time
import statistics
 
def timing_fingerprint(api_client, num_trials=20):
    """
    Fingerprint model using response timing characteristics.
    """
    # Fixed prompt for consistent comparison
    prompt = "Count from 1 to 10, one number per line."
 
    timings = []
    for _ in range(num_trials):
        start = time.monotonic()
        response = api_client.generate(
            prompt, max_tokens=50, temperature=0
        )
        elapsed = time.monotonic() - start
        timings.append(elapsed)
 
    return {
        "median_latency": statistics.median(timings),
        "p95_latency": sorted(timings)[int(0.95 * len(timings))],
        "variance": statistics.variance(timings),
        "tokens_per_second": 50 / statistics.median(timings),
        # Larger models generally have slower tokens/second
    }

ATTACK_RECOMMENDATIONS = {
    "OpenAI GPT": {
        "effective_techniques": [
            "multi-turn escalation",
            "role-play framing",
            "few-shot jailbreaking"
        ],
        "known_weaknesses": [
            "instruction hierarchy bypass via developer messages",
            "function calling manipulation"
        ],
        "less_effective": [
            "direct instruction override (well-defended)",
            "GCG suffixes (actively filtered)"
        ]
    },
    "Anthropic Claude": {
        "effective_techniques": [
            "many-shot jailbreaking",
            "role-play with detailed personas",
            "progressive topic shifting"
        ],
        "known_weaknesses": [
            "long-context attention patterns",
            "system prompt extraction via reasoning"
        ],
        "less_effective": [
            "simple DAN-style prompts",
            "basic instruction override"
        ]
    },
    # ... additional model families
}