Delete ASP/qwen_agents/Profiler_agent/.ipynb_checkpoints

ASP/qwen_agents/Profiler_agent/.ipynb_checkpoints/OUTPUT-checkpoint.md

@@ -1,39 +0,0 @@
-# Output Formatting
-
-Write your response as a Markdown report with these sections, in order:
-
-## Crime Scene Report
-Describe what is visible across the case images: setting, victim positioning
-(if applicable), signs of planning vs. improvisation, anything inconsistent
-with a normal/expected version of the scene (e.g. a living room, park, or
-other setting), and any apparent staging, concealment, or lack thereof.
-
-## Victimology
-What the images/notes suggest about victim selection, means of access, and
-relationship (if any) between offender and victim.
-
-## Organization Level
-Classify the scene as **Organized**, **Disorganized**, or **Mixed**, based on
-the classic distinction:
-- *Organized*: planning evident, victim/scene control, concealment or careful
-  disposal, deliberate cleanup — associated with higher intelligence and
-  social integration.
-- *Disorganized*: little planning, scene left as-is, minimal concealment,
-  higher apparent anxiety/impulsivity.
-- *Mixed*: elements of both.
-
-## Offender Typology
-Using the classification frameworks in `REFERENCE.md` (Palermo/Mastronardi's
-typology and the Holmes & Holmes typology), identify which types best fit
-the evidence; for example (not exhaustive): Visionary, Missionary (and its
-subtypes), Hedonistic, Power/Control-oriented, or Lust-oriented, including
-any atypical variant if applicable. You do not need to force a single type
-if the evidence is ambiguous — say so and name the top 1-2 candidates.
-
-## Rationale & Confidence
-2-4 sentences tying your classification directly to specific evidence from
-the Forensic agent's report and the case images. State your confidence
-explicitly (Low / Medium / High) based on how much evidence is actually
-available. This is an analytical classification for casework support, not a
-certainty — frame it as the most likely interpretation of the evidence, not
-a definitive claim.

ASP/qwen_agents/Profiler_agent/.ipynb_checkpoints/image_viewer_mcp-checkpoint.py

@@ -1,174 +0,0 @@
-import io
-import os
-import re
-import sys
-from dataclasses import dataclass, field
-from pathlib import Path
-from fastmcp import FastMCP
-from fastmcp.exceptions import ToolError
-from fastmcp.utilities.types import Image
-from PIL import Image as PILImage
-
-DEFAULT_SKILL_DIR = Path(__file__).parent / ".agents" / "skills" / "criminal-behavioral-analysis"
-IMAGE_SUFFIXES = {".jpg", ".jpeg", ".png", ".webp"}
-IMAGE_MARKDOWN = re.compile(r"!\[(?P<alt>.*?)\]\((?P<path>.*?)\)")
-ADVANCED_HEADING = "# Advanced version"
-
-
-@dataclass
-class Section:
-    number: int
-    label: str
-    title: str
-    images: list[Path] = field(default_factory=list)
-
-
-class AdvancedImageLibrary:
-    def __init__(self, skill_dir: Path, max_side: int = 1600, max_per_call: int = 4):
-        self.skill_dir = skill_dir.resolve()
-        self.long_dir = self.skill_dir / "assets" / "long"
-        self.reference_file = self.skill_dir / "references" / "REFERENCE.md"
-        self.max_side = max_side
-        self.max_per_call = max_per_call
-        titles, self.descriptions = self.read_reference()
-        self.sections = self.read_sections(titles)
-
-    def read_reference(self) -> tuple[list[str], dict[Path, str]]:
-        titles: list[str] = []
-        alts: dict[Path, str] = {}
-        if not self.reference_file.exists():
-            return titles, alts
-        in_advanced = False
-        for line in self.reference_file.read_text(encoding="utf-8").splitlines():
-            if line.strip() == ADVANCED_HEADING:
-                in_advanced = True
-            elif in_advanced and line.startswith("## "):
-                titles.append(line[3:].strip())
-            elif in_advanced:
-                for match in IMAGE_MARKDOWN.finditer(line):
-                    alts[(self.skill_dir / match["path"]).resolve()] = match["alt"].strip()
-        return titles, alts
-
-    def read_sections(self, titles: list[str]) -> list[Section]:
-        folders = sorted(
-            (d for d in self.long_dir.iterdir() if d.is_dir()),
-            key=lambda d: [int(t) if t.isdigit() else t for t in re.split(r"(\d+)", d.name)],
-        ) if self.long_dir.is_dir() else []
-        use_titles = len(titles) == len(folders)
-        sections = []
-        for index, folder in enumerate(folders, start=1):
-            images = sorted(
-                (p for p in folder.iterdir() if p.suffix.lower() in IMAGE_SUFFIXES),
-                key=lambda p: [int(t) if t.isdigit() else t for t in re.split(r"(\d+)", p.name)],
-            )
-            sections.append(Section(
-                number=index,
-                label=folder.name,
-                title=titles[index - 1] if use_titles else folder.name,
-                images=images,
-            ))
-        return sections
-
-    @property
-    def image_count(self) -> int:
-        return sum(len(s.images) for s in self.sections)
-
-    def describe(self, path: Path) -> str:
-        return self.descriptions.get(path.resolve(), "")
-
-    def relative(self, path: Path) -> str:
-        return path.resolve().relative_to(self.long_dir).as_posix()
-
-    def find_section(self, query: str) -> Section:
-        wanted = str(query).strip().lower()
-        if wanted.isdigit():
-            for section in self.sections:
-                if section.number == int(wanted):
-                    return section
-        for section in self.sections:
-            if wanted and (wanted in section.title.lower() or wanted in section.label.lower()):
-                return section
-        choices = "; ".join(f"{s.number}: {s.title}" for s in self.sections)
-        raise ToolError(f"No section matches {query!r}. Available sections: {choices}")
-
-    def resolve_image(self, relative_path: str) -> Path:
-        candidate = (self.long_dir / relative_path).resolve()
-        if not candidate.is_relative_to(self.long_dir) or candidate.suffix.lower() not in IMAGE_SUFFIXES:
-            raise ToolError(f"{relative_path!r} is not an Advanced version image")
-        if not candidate.is_file():
-            raise ToolError(f"{relative_path!r} does not exist; call list_sections to see valid paths")
-        return candidate
-
-    def load(self, path: Path) -> Image:
-        with PILImage.open(path) as picture:
-            if max(picture.size) <= self.max_side:
-                return Image(path=str(path))
-            picture = picture.convert("RGB")
-            picture.thumbnail((self.max_side, self.max_side), PILImage.Resampling.LANCZOS)
-            buffer = io.BytesIO()
-            picture.save(buffer, format="JPEG", quality=88)
-        return Image(data=buffer.getvalue(), format="jpeg")
-
-
-def build_server(library: AdvancedImageLibrary) -> FastMCP:
-    server = FastMCP("image-viewer")
-
-    @server.tool
-    def list_sections() -> list[dict]:
-        return [
-            {
-                "section": s.number,
-                "title": s.title,
-                "image_count": len(s.images),
-                "images": [
-                    {"path": library.relative(p), "description": library.describe(p)}
-                    for p in s.images
-                ],
-            }
-            for s in library.sections
-        ]
-
-    @server.tool
-    def view_section(section: str, offset: int = 0) -> list:
-        chosen = library.find_section(section)
-        start = max(int(offset), 0)
-        batch = chosen.images[start:start + library.max_per_call]
-        if not batch:
-            raise ToolError(
-                f"Section {chosen.number} has {len(chosen.images)} images; offset {start} is past the end"
-            )
-        end = start + len(batch)
-        header = f"Section {chosen.number}: {chosen.title} - images {start + 1} to {end} of {len(chosen.images)}"
-        footer = (
-            f"{len(chosen.images) - end} more image(s) in this section; call view_section again with offset={end}."
-            if end < len(chosen.images) else "End of section."
-        )
-        content: list = [header]
-        for path in batch:
-            description = library.describe(path)
-            content.append(f"{library.relative(path)}" + (f" - {description}" if description else ""))
-            content.append(library.load(path))
-        content.append(footer)
-        return content
-
-    @server.tool
-    def view_image(path: str) -> list:
-        resolved = library.resolve_image(path)
-        description = library.describe(resolved)
-        return [library.relative(resolved) + (f" - {description}" if description else ""), library.load(resolved)]
-
-    return server
-
-
-def main() -> None:
-    skill_dir = Path(sys.argv[1]) if len(sys.argv) > 1 else DEFAULT_SKILL_DIR
-    library = AdvancedImageLibrary(
-        skill_dir,
-        max_side=int(os.getenv("IMAGE_VIEWER_MAX_SIDE", "1600")),
-        max_per_call=int(os.getenv("IMAGE_VIEWER_MAX_PER_CALL", "4")),
-    )
-    build_server(library).run(transport="stdio", show_banner=False)
-
-
-if __name__ == "__main__":
-    main()

ASP/qwen_agents/Profiler_agent/.ipynb_checkpoints/profiler_agent-checkpoint.py

@@ -1,141 +0,0 @@
-import logging
-import os
-import sys
-from pathlib import Path
-from fastmcp.client import Client as FastMCPClient
-from fastmcp.client.transports import StdioTransport
-from pydantic_ai import Agent, RunContext
-from pydantic_ai.mcp import MCPToolset
-from qwen_agents.model_utils import QwenVLModel
-from reference_version import ADVANCED, BASIC, version_from_messages
-
-log = logging.getLogger(__name__)
-
-PROFILER_MODEL_ID = os.getenv(
-    "PROFILER_MODEL_ID", "Kizzington/Qwen3-VL-8B-Thinking-heretic"
-)
-
-PROFILER_LOAD_IN_4BIT = os.getenv("PROFILER_LOAD_IN_4BIT", "false").strip().lower() not in (
-    "false", "0", "no"
-)
-
-SKILLS_DIR = Path(__file__).parent / ".agents" / "skills"
-CBA_SKILL_DIR = SKILLS_DIR / "criminal-behavioral-analysis"
-PROFILER_SKILL = CBA_SKILL_DIR / "SKILL.md"
-
-SHORT_REFERENCE_IMAGES = sorted(
-    (CBA_SKILL_DIR / "assets" / "short").glob("*.jpg")
-)
-ADVANCED_IMAGE_COUNT = len(list((CBA_SKILL_DIR / "assets" / "long").rglob("*.jpg")))
-
-IMAGE_VIEWER_SERVER = Path(__file__).parent / "image_viewer_mcp.py"
-
-skills_client = FastMCPClient(
-    StdioTransport(
-        command=sys.executable,
-        args=[str(IMAGE_VIEWER_SERVER), str(CBA_SKILL_DIR)],
-        env={**os.environ}
-    ),
-    init_timeout=60
-)
-ALLOWED_SKILL_TOOLS = {"list_sections", "view_section", "view_image"}
-skills_toolset = MCPToolset(skills_client).filtered(
-    lambda ctx, tool_def: (
-        tool_def.name in ALLOWED_SKILL_TOOLS and version_from_messages(ctx.messages) != BASIC
-    )
-)
-
-
-def load_skill_text(path: Path) -> str:
-    try:
-        return path.read_text(encoding="utf-8")
-    except FileNotFoundError as e:
-        raise RuntimeError(
-            f"Profiler agent's required skill file is missing: {path} "
-            "— this file defines the agent's core workflow and output "
-            "format; the agent cannot run correctly without it."
-        ) from e
-
-
-SKILL_MD = load_skill_text(PROFILER_SKILL)
-OUTPUT_MD = load_skill_text(CBA_SKILL_DIR / "references" / "OUTPUT.md")
-
-
-profiler_agent: Agent[None, str] = Agent(
-    model=QwenVLModel(
-        PROFILER_MODEL_ID,
-        processor_path="Qwen/Qwen3-VL-8B-Thinking",
-        reference_images=SHORT_REFERENCE_IMAGES,
-        temperature=0.3,
-        max_new_tokens=12288,
-        load_in_4bit=PROFILER_LOAD_IN_4BIT
-    ).function_model(),
-    system_prompt=(
-        "You are a criminal behavioral profiler analyzing case images plus "
-        "a Forensic agent's report (received via A2A).\n\n"
-        "You are NOT deriving forensic conclusions yourself — use the "
-        "Forensic report's findings as evidence for your profile. Do NOT "
-        "just repeat or extend the Forensic report's own format (cause of "
-        "death, manner of death, etc.) — your job is a DIFFERENT, "
-        "behavioral-profiling report, as described in your skill file "
-        "below.\n\n"
-        "Note: some runs of this pipeline supply the Forensic report "
-        "concurrently with RAG grounding lookup rather than waiting for "
-        "it, so grounded reference material from forensic_knowledge/ may "
-        "or may not be present below — proceed with whatever you're given "
-        "and don't assume its absence means none exists.\n\n"
-        "You have already been given several reference images (the 'Basic "
-        "version' of your training material) summarizing established "
-        "criminological classification frameworks for serial offenders, "
-        "including:\n"
-        "  - Palermo/Mastronardi's typology (Visionary, Missionary [with "
-        "subtypes: social protection, pseudo-religious, pseudo-political, "
-        "pseudo-cultural, racial, sexological-moralist, of the social "
-        "order], Hedonistic, Power/Control-oriented, Lust-oriented, plus "
-        "atypical variants)\n"
-        "  - The Holmes & Holmes typology (male and female variants)\n"
-        "  - Organized vs. Disorganized vs. Mixed crime-scene classification\n\n"
-        "--- Your skill file (criminal-behavioral-analysis/SKILL.md) ---\n"
-        "This defines your workflow. It is included here directly so you "
-        "always have it regardless of whether you call any tool — you may "
-        "still optionally use the image viewer tools to go deeper into the "
-        "Advanced version images as it describes below.\n\n"
-        f"TOOL RULES: your only tools are list_sections, view_section and view_image, "
-        f"and they only show the {ADVANCED_IMAGE_COUNT} Advanced version reference images. "
-        "list_sections lists the sections with a description of each image; view_section "
-        "returns the actual images of one section (a few at a time, use offset to page); "
-        "view_image returns one image by the path list_sections gave you. The case images "
-        "are ALREADY attached to this message: never try to open, locate or re-read them "
-        "with a tool, and never invent file paths such as /data/.... If a tool returns an "
-        "error, do NOT repeat the same call; continue with what you already have.\n\n"
-        f"{SKILL_MD}\n\n"
-        "--- Your required output format (references/OUTPUT.md), verbatim ---\n"
-        "You MUST use exactly these Markdown sections, in this order:\n\n"
-        f"{OUTPUT_MD}\n\n"
-        "---\n\n"
-        "CRITICAL — avoid speculation: base every claim on what is "
-        "actually visible in the images or stated in the Forensic report. "
-        "Never invent specific unsupported narrative details (e.g. a "
-        "specific relationship between victim and offender, a specific "
-        "motive scenario, or a named category of crime) unless the "
-        "evidence in front of you actually supports it — if the evidence "
-        "is weak or absent for a claim, say so explicitly rather than "
-        "filling the gap with an invented specific."
-    ),
-    toolsets=[skills_toolset],
-    retries=4
-)
-
-
-@profiler_agent.output_validator
-def warn_if_advanced_unused(ctx: RunContext[None], output: str) -> str:
-    if version_from_messages(ctx.messages) == ADVANCED:
-        viewed = any(
-            getattr(part, "tool_name", None) in ALLOWED_SKILL_TOOLS
-            for message in ctx.messages
-            for part in getattr(message, "parts", ())
-            if getattr(part, "part_kind", None) == "tool-call"
-        )
-        if not viewed:
-            log.warning("Advanced reference version was selected but the model never viewed an Advanced page")
-    return output