agentic-qa 0.1.0__py3-none-any.whl

agentic_qa/__init__.py

@@ -0,0 +1,103 @@
+"""
+Agentic QA - Main Public API
+
+This file exposes the simple `run_autonomous_test` function, allowing developers 
+to test their RAG systems in just a few lines of code.
+"""
+
+import os
+from typing import Callable, Optional
+
+# Expose SUT adapters for developers if they want advanced setups
+from agentic_qa.sut.base import BaseSUTAdapter
+from agentic_qa.sut.api_adapter import APIAdapter
+from agentic_qa.sut.callable_adapter import CallableAdapter
+from agentic_qa.sut import set_active_sut
+
+# Import the core workflow
+from agentic_qa.graph.workflow import build_qa_graph, get_initial_state
+
+
+def run_autonomous_test(
+    target_function: Optional[Callable] = None,
+    api_endpoint: Optional[str] = None,
+    system_name: str = "Target System",
+    system_description: str = "A generic RAG system",
+    domain: str = "general",
+    max_iterations: int = 3,
+    tests_per_iteration: int = 5,
+    model_name: str = "gpt-4o-mini",
+) -> dict:
+    """
+    Run an autonomous multi-agent QA test against a target system.
+    
+    You must provide EITHER a `target_function` (a python function) OR 
+    an `api_endpoint` (a URL string).
+    
+    Args:
+        target_function: A python function that takes a string query and returns a string answer.
+        api_endpoint: A URL endpoint (e.g., http://localhost:8000/chat) to test.
+        system_name: The name of the system being tested.
+        system_description: A description of what the system does. Highly important for agents!
+        domain: The domain of the system (e.g., 'financial', 'healthcare', 'customer support').
+        max_iterations: How many times the agents should refine and retry their tests.
+        tests_per_iteration: How many tests the Red-Team agent generates per round.
+        model_name: The LLM to use for the agents (default: gpt-4o-mini).
+        
+    Returns:
+        A dictionary containing the final execution state, including the test suite, verdicts,
+        failure patterns, and the final Markdown report.
+    """
+    # 1. Configure Environment variables needed by LangGraph
+    os.environ["MAX_ITERATIONS"] = str(max_iterations)
+    os.environ["TESTS_PER_ITERATION"] = str(tests_per_iteration)
+    os.environ["MODEL_NAME"] = model_name
+    
+    # 2. Setup the SUT Adapter
+    if target_function:
+        adapter = CallableAdapter(
+            fn=target_function,
+            description=system_description,
+            system_name=system_name,
+            domain=domain
+        )
+    elif api_endpoint:
+        adapter = APIAdapter(
+            endpoint=api_endpoint,
+            description=system_description,
+            system_name=system_name,
+            domain=domain
+        )
+    else:
+        raise ValueError("You must provide either a `target_function` or an `api_endpoint`.")
+
+    # Register the adapter globally for the Executor Agent to use
+    set_active_sut(adapter)
+    
+    # 3. Build and Run the Graph
+    print(f"🚀 Starting Autonomous QA Test against: {system_name}")
+    print(f"Domain: {domain} | Max Iterations: {max_iterations}")
+    
+    graph = build_qa_graph()
+    initial_state = get_initial_state()
+    initial_state["max_iterations"] = max_iterations
+    
+    final_state = None
+    # Stream the graph to provide real-time console feedback
+    for event in graph.stream(initial_state, stream_mode="values"):
+        final_state = event
+        
+    print("\n✅ Autonomous QA Test Complete!")
+    print(f"Coverage Score: {final_state.get('coverage_score', 0):.1%}")
+    print(f"Total Failure Patterns Found: {len(final_state.get('failure_patterns', []))}")
+    
+    return final_state
+
+
+# Define what is exported when someone runs `from agentic_qa import *`
+__all__ = [
+    "run_autonomous_test",
+    "APIAdapter",
+    "CallableAdapter",
+    "BaseSUTAdapter"
+]

agentic_qa/agents/__init__.py

@@ -0,0 +1,15 @@
+"""Multi-Agent Autonomous QA System - Agents Package"""
+
+from agentic_qa.agents.red_team import red_team_node
+from agentic_qa.agents.executor import executor_node
+from agentic_qa.agents.judge import judge_node
+from agentic_qa.agents.refiner import refiner_node
+from agentic_qa.agents.reporter import reporter_node
+
+__all__ = [
+    "red_team_node",
+    "executor_node", 
+    "judge_node",
+    "refiner_node",
+    "reporter_node",
+]

agentic_qa/agents/discovery.py

@@ -0,0 +1,88 @@
+"""
+Discovery Agent (Graphify) — Architecture Mapping.
+
+This agent performs White-Box introspection. It analyzes the System Under Test (SUT)
+and maps out its internal architecture (e.g., Vector DB, Chunk Size, Retriever type, LLM).
+This architectural "graph" allows the Red-Team agent to launch hyper-targeted attacks.
+"""
+
+import os
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import SystemMessage, HumanMessage
+from agentic_qa.graph.state import QAState
+
+DISCOVERY_SYSTEM_PROMPT = """You are an elite AI Architecture Mapper (Graphify Agent).
+
+Your mission is to analyze a generic description of an AI/RAG system and deduce its likely internal architecture graph.
+You must break down the system into a logical pipeline (e.g., Data Ingestion -> Chunking -> VectorDB -> Retriever -> LLM -> Output).
+
+Think about:
+1. What components must exist for this system to work?
+2. Where are the likely weak points or bottlenecks between these nodes?
+3. What are the assumed configurations (e.g., chunk size, top-k retrieval)?
+
+Output a detailed, graph-like text representation of the architecture. Be specific about potential vulnerabilities at each node."""
+
+DISCOVERY_USER_PROMPT = """Analyze the following System Under Test and map its architecture.
+
+**System Name:** {name}
+**Domain:** {domain}
+**Description:**
+{description}
+
+Provide a detailed architectural breakdown (Graphify) of this system. Highlight the specific nodes (e.g., Retriever, VectorStore, LLM) and the data flow. 
+Keep it concise but technical."""
+
+
+def _get_llm() -> ChatOpenAI:
+    return ChatOpenAI(
+        model=os.getenv("MODEL_NAME", "gpt-4o-mini"),
+        temperature=0.2,
+        openai_api_key=os.getenv("OPENAI_API_KEY"),
+        openai_api_base=os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1"),
+    )
+
+
+def discovery_node(state: QAState) -> dict:
+    """
+    LangGraph node: Discovery Agent.
+    
+    Runs once at the beginning of the pipeline to map the SUT architecture.
+    """
+    print(f"\n{'='*60}")
+    print(f"🔍 DISCOVERY AGENT (Graphify) — Mapping Architecture")
+    print(f"{'='*60}")
+    
+    description = state.get("sut_description", "")
+    domain = state.get("domain", "")
+    
+    # If the architecture is already provided (e.g. by the adapter), skip LLM discovery
+    if state.get("sut_architecture"):
+        print("  Architecture already provided. Skipping LLM discovery.")
+        return {}
+        
+    print("  Analyzing SUT description to deduce internal graph...")
+    
+    llm = _get_llm()
+    prompt = DISCOVERY_USER_PROMPT.format(
+        name="Target System",
+        domain=domain,
+        description=description
+    )
+    
+    messages = [
+        SystemMessage(content=DISCOVERY_SYSTEM_PROMPT),
+        HumanMessage(content=prompt)
+    ]
+    
+    response = llm.invoke(messages)
+    architecture = response.content
+    
+    print("\n  🗺️ Deduced Architecture Graph:")
+    # Print the first few lines as a preview
+    preview = "\n".join([f"    {line}" for line in architecture.split("\n")[:10]])
+    print(f"{preview}\n    ...")
+    
+    return {
+        "sut_architecture": architecture
+    }

agentic_qa/agents/executor.py

@@ -0,0 +1,89 @@
+"""
+Executor Agent — Generic System Under Test Runner.
+
+Executes test cases against ANY connected SUT (RAG, API, function).
+Uses the active SUT adapter from the registry — works with:
+  - Built-in Financial RAG demo
+  - Any RAG connected via API endpoint
+  - Any Python function wrapped as a callable
+"""
+
+import time
+from agentic_qa.graph.state import QAState
+from agentic_qa.sut import get_active_sut
+
+
+def executor_node(state: QAState) -> dict:
+    """
+    LangGraph node: Executor Agent.
+    
+    Runs each test case from the current iteration through whatever
+    SUT is currently active and collects results.
+    """
+    iteration = state.get("current_iteration", 1)
+    test_suite = state.get("test_suite", [])
+    
+    print(f"\n{'='*60}")
+    print(f"⚡ EXECUTOR AGENT — Iteration {iteration}")
+    print(f"{'='*60}")
+    
+    # Get test cases for the current iteration only
+    iter_prefix = f"TC-{iteration:02d}"
+    current_tests = [tc for tc in test_suite if tc["id"].startswith(iter_prefix)]
+    
+    if not current_tests:
+        num_per_iter = 5
+        current_tests = test_suite[-num_per_iter:]
+    
+    # Get the active SUT (whatever the user connected)
+    sut = get_active_sut()
+    print(f"  SUT: {sut.name}")
+    print(f"  Executing {len(current_tests)} test cases...")
+    
+    execution_results = []
+    
+    for tc in current_tests:
+        test_id = tc["id"]
+        input_data = tc["input_data"]
+        
+        print(f"  ▶ Running [{test_id}]...", end=" ")
+        
+        start_time = time.time()
+        try:
+            output = sut.process(input_data)
+            exec_time = time.time() - start_time
+            
+            # Normalize output — adapters return "output" key
+            sut_output = output.get("output", output.get("sut_output", str(output)))
+            status = output.get("status", "unknown")
+            
+            result = {
+                "test_id": test_id,
+                "sut_output": str(output),
+                "execution_time": round(exec_time, 4),
+                "error": output.get("error") if status == "error" else None,
+            }
+            print(f"Done ({exec_time:.3f}s) — Status: {status}")
+            
+        except Exception as e:
+            exec_time = time.time() - start_time
+            result = {
+                "test_id": test_id,
+                "sut_output": "",
+                "execution_time": round(exec_time, 4),
+                "error": str(e),
+            }
+            print(f"ERROR ({exec_time:.3f}s) — {e}")
+        
+        execution_results.append(result)
+    
+    errors = sum(1 for r in execution_results if r["error"])
+    avg_time = sum(r["execution_time"] for r in execution_results) / max(len(execution_results), 1)
+    print(f"\n  📊 Execution Summary:")
+    print(f"     Tests executed: {len(execution_results)}")
+    print(f"     Errors/crashes: {errors}")
+    print(f"     Avg exec time:  {avg_time:.3f}s")
+    
+    return {
+        "execution_results": execution_results,
+    }

agentic_qa/agents/judge.py

@@ -0,0 +1,231 @@
+"""
+Judge Agent — LLM-as-Judge Evaluator.
+
+This agent evaluates each test case's expected behavior against the SUT's
+actual output, delivering precise pass/fail verdicts with detailed reasoning.
+
+Uses the LLM-as-Judge pattern: the LLM acts as an impartial evaluator
+that understands financial domain expectations.
+"""
+
+import json
+import os
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import SystemMessage, HumanMessage
+from agentic_qa.graph.state import QAState
+from agentic_qa.utils.prompt_templates import JUDGE_SYSTEM_PROMPT, JUDGE_EVALUATION_PROMPT
+
+
+def _get_llm() -> ChatOpenAI:
+    """Initialize the LLM for the Judge Agent."""
+    return ChatOpenAI(
+        model=os.getenv("MODEL_NAME", "gpt-4o-mini"),
+        temperature=0.1,  # Low temperature for consistent, precise judgments
+        openai_api_key=os.getenv("OPENAI_API_KEY"),
+        openai_api_base=os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1"),
+    )
+
+
+def _build_test_results_json(state: QAState) -> str:
+    """Combine test cases with execution results for judge evaluation."""
+    iteration = state.get("current_iteration", 1)
+    test_suite = state.get("test_suite", [])
+    execution_results = state.get("execution_results", [])
+    
+    # Build lookup of execution results by test_id
+    results_map = {r["test_id"]: r for r in execution_results}
+    
+    # Get current iteration tests
+    iter_prefix = f"TC-{iteration:02d}"
+    current_tests = [tc for tc in test_suite if tc["id"].startswith(iter_prefix)]
+    if not current_tests:
+        num_per_iter = 5
+        current_tests = test_suite[-num_per_iter:]
+    
+    # Combine test case + result for each
+    combined = []
+    for tc in current_tests:
+        result = results_map.get(tc["id"], {})
+        combined.append({
+            "test_id": tc["id"],
+            "input_data": tc["input_data"],
+            "expected_behavior": tc["expected_behavior"],
+            "edge_case_type": tc["edge_case_type"],
+            "difficulty": tc["difficulty"],
+            "sut_output": result.get("sut_output", "NO OUTPUT"),
+            "execution_error": result.get("error"),
+            "execution_time": result.get("execution_time", 0),
+        })
+    
+    return combined, json.dumps(combined, indent=2)
+
+
+def _parse_verdicts(response_text: str) -> tuple:
+    """Parse Judge LLM response into structured verdicts."""
+    try:
+        text = response_text.strip()
+        if "```json" in text:
+            text = text.split("```json")[1].split("```")[0].strip()
+        elif "```" in text:
+            text = text.split("```")[1].split("```")[0].strip()
+        
+        data = json.loads(text)
+        verdicts = data.get("verdicts", [])
+        pass_rate = data.get("pass_rate", 0.0)
+        summary = data.get("summary", "")
+        
+        normalized = []
+        for v in verdicts:
+            normalized.append({
+                "test_id": v.get("test_id", "unknown"),
+                "status": v.get("status", "error"),
+                "reasoning": v.get("reasoning", "No reasoning provided"),
+                "severity": v.get("severity", "medium"),
+                "failure_category": v.get("failure_category"),
+                "confidence": float(v.get("confidence", 0.5)),
+            })
+        
+        return normalized, pass_rate, summary
+        
+    except (json.JSONDecodeError, KeyError, IndexError) as e:
+        print(f"  ⚠️  Failed to parse Judge response: {e}")
+        return [], 0.0, "Failed to parse judge evaluation"
+
+
+def _run_ragas_evaluation(combined_results: list) -> dict:
+    """Run Ragas mathematical metrics on the results."""
+    try:
+        from datasets import Dataset
+        from ragas import evaluate
+        from ragas.metrics import answer_relevancy
+        from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+        import os
+        
+        # 1. Explicitly initialize the models so Ragas doesn't try to guess
+        eval_llm = ChatOpenAI(
+            model=os.getenv("MODEL_NAME", "gpt-4o-mini"),
+            openai_api_key=os.getenv("OPENAI_API_KEY")
+        )
+        eval_embeddings = OpenAIEmbeddings(
+            openai_api_key=os.getenv("OPENAI_API_KEY")
+        )
+        
+        # Format for Ragas
+        data = {
+            "question": [],
+            "answer": [],
+            "contexts": [],
+        }
+        
+        for r in combined_results:
+            data["question"].append(str(r["input_data"]))
+            data["answer"].append(str(r["sut_output"]))
+            data["contexts"].append(["Black-box evaluation context"])
+            
+        dataset = Dataset.from_dict(data)
+        
+        print("  🧮 Running RAGAS mathematical evaluation (Answer Relevancy)...")
+        # 2. Pass the LLM and Embeddings directly into evaluate
+        result = evaluate(
+            dataset, 
+            metrics=[answer_relevancy], 
+            llm=eval_llm,
+            embeddings=eval_embeddings,
+            raise_exceptions=False
+        )
+        scores_df = result.to_pandas()
+        
+        ragas_scores = {}
+        for idx, row in scores_df.iterrows():
+            test_id = combined_results[idx]["test_id"]
+            ragas_scores[test_id] = {
+                "ragas_answer_relevancy": float(row.get("answer_relevancy", 0.0))
+            }
+            
+        return ragas_scores
+        
+    except Exception as e:
+        print(f"  ⚠️  Ragas evaluation skipped/failed: {e}")
+        return {}
+
+
+def judge_node(state: QAState) -> dict:
+    """
+    LangGraph node: Judge Agent.
+    
+    Evaluates SUT outputs against expected behaviors using LLM-as-Judge.
+    
+    Args:
+        state: Current QAState
+        
+    Returns:
+        State update with judge_verdicts and all_verdicts accumulation
+    """
+    iteration = state.get("current_iteration", 1)
+    
+    print(f"\n{'='*60}")
+    print(f"⚖️  JUDGE AGENT — Iteration {iteration}")
+    print(f"{'='*60}")
+    print(f"  Evaluating test results...")
+    
+    # Build the evaluation context
+    combined_results, test_results_json = _build_test_results_json(state)
+    
+    # Run mathematical Ragas evaluation
+    ragas_scores = _run_ragas_evaluation(combined_results)
+    
+    evaluation_prompt = JUDGE_EVALUATION_PROMPT.format(
+        test_results_json=test_results_json
+    )
+    
+    # Call the LLM — format system prompt with domain context
+    llm = _get_llm()
+    system_prompt = JUDGE_SYSTEM_PROMPT.format(
+        sut_description=state.get("sut_description", "Unknown System"),
+        domain=state.get("domain", "general"),
+    )
+    messages = [
+        SystemMessage(content=system_prompt),
+        HumanMessage(content=evaluation_prompt),
+    ]
+    
+    response = llm.invoke(messages)
+    
+    # Parse verdicts
+    verdicts, pass_rate, summary = _parse_verdicts(response.content)
+    
+    # Inject Ragas scores into the verdicts
+    for v in verdicts:
+        tid = v["test_id"]
+        if tid in ragas_scores:
+            v["ragas_scores"] = ragas_scores[tid]
+    
+    # Print results
+    pass_count = sum(1 for v in verdicts if v["status"] == "pass")
+    fail_count = sum(1 for v in verdicts if v["status"] == "fail")
+    error_count = sum(1 for v in verdicts if v["status"] == "error")
+    
+    print(f"\n  📋 Verdict Summary:")
+    print(f"     ✅ Passed:  {pass_count}")
+    print(f"     ❌ Failed:  {fail_count}")
+    print(f"     💥 Errors:  {error_count}")
+    print(f"     📈 Pass Rate: {pass_rate:.1%}")
+    print(f"\n  Detailed Verdicts:")
+    
+    for v in verdicts:
+        icon = "✅" if v["status"] == "pass" else "❌" if v["status"] == "fail" else "💥"
+        score_str = ""
+        if "ragas_scores" in v:
+            rel = v['ragas_scores'].get('ragas_answer_relevancy', 0)
+            score_str = f"| Relevancy: {rel:.2f}"
+            
+        print(f"     {icon} [{v['test_id']}] {v['status'].upper():7s} | {v['severity']:8s} {score_str} | {v['reasoning'][:50]}...")
+    
+    if summary:
+        print(f"\n  💬 Summary: {summary[:100]}...")
+    
+    return {
+        "judge_verdicts": verdicts,
+        "all_verdicts": verdicts,
+        "iteration_pass_rates": [pass_rate],
+    }

agentic_qa/agents/red_team.py

@@ -0,0 +1,162 @@
+"""
+Red-Team Agent — Adversarial Test Case Generator.
+
+This agent autonomously generates diverse, creative adversarial test inputs
+targeting edge cases and vulnerabilities in the financial document SUT.
+
+On iteration 1, it generates broad-spectrum tests. On subsequent iterations,
+it uses failure patterns from the Refiner Agent to generate increasingly
+targeted and sophisticated test cases.
+"""
+
+import json
+import os
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import SystemMessage, HumanMessage
+from agentic_qa.graph.state import QAState
+from agentic_qa.utils.prompt_templates import (
+    RED_TEAM_SYSTEM_PROMPT,
+    RED_TEAM_GENERATION_PROMPT,
+    RED_TEAM_REFINEMENT_CONTEXT,
+)
+
+
+def _get_llm() -> ChatOpenAI:
+    """Initialize the LLM for the Red-Team Agent."""
+    return ChatOpenAI(
+        model=os.getenv("MODEL_NAME", "gpt-4o-mini"),
+        temperature=0.9,  # High creativity for diverse adversarial inputs
+        openai_api_key=os.getenv("OPENAI_API_KEY"),
+        openai_api_base=os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1"),
+    )
+
+
+def _build_failure_context(state: QAState) -> str:
+    """Build context from previous failures to guide targeted generation."""
+    failure_patterns = state.get("failure_patterns", [])
+    all_verdicts = state.get("all_verdicts", [])
+    
+    if not failure_patterns and not all_verdicts:
+        return "This is the FIRST iteration. Generate a diverse initial test suite covering all edge case categories."
+    
+    # Count failures
+    total_tests = len(all_verdicts)
+    total_failures = sum(1 for v in all_verdicts if v.get("status") in ("fail", "error"))
+    
+    # Find top failure categories
+    categories = {}
+    for v in all_verdicts:
+        if v.get("status") in ("fail", "error"):
+            cat = v.get("failure_category", "unknown")
+            categories[cat] = categories.get(cat, 0) + 1
+    
+    top_categories = sorted(categories.items(), key=lambda x: x[1], reverse=True)[:5]
+    top_str = ", ".join([f"{cat} ({count})" for cat, count in top_categories])
+    
+    return RED_TEAM_REFINEMENT_CONTEXT.format(
+        failure_patterns="\n".join(f"  - {p}" for p in failure_patterns[-10:]),
+        total_tests=total_tests,
+        total_failures=total_failures,
+        top_failure_categories=top_str or "None identified yet",
+    )
+
+
+def _parse_test_cases(response_text: str, iteration: int) -> list:
+    """Parse LLM response into structured test cases."""
+    try:
+        # Try to extract JSON from the response
+        # Handle cases where LLM wraps JSON in markdown code blocks
+        text = response_text.strip()
+        if "```json" in text:
+            text = text.split("```json")[1].split("```")[0].strip()
+        elif "```" in text:
+            text = text.split("```")[1].split("```")[0].strip()
+        
+        data = json.loads(text)
+        test_cases = data.get("test_cases", [])
+        
+        # Validate and normalize each test case
+        normalized = []
+        for i, tc in enumerate(test_cases):
+            normalized.append({
+                "id": tc.get("id", f"TC-{iteration:02d}{i+1:02d}"),
+                "input_data": tc.get("input_data", ""),
+                "expected_behavior": tc.get("expected_behavior", ""),
+                "edge_case_type": tc.get("edge_case_type", "adversarial"),
+                "difficulty": tc.get("difficulty", "medium"),
+                "rationale": tc.get("rationale", ""),
+            })
+        
+        return normalized
+        
+    except (json.JSONDecodeError, KeyError, IndexError) as e:
+        print(f"  ⚠️  Failed to parse Red-Team response: {e}")
+        # Fallback: generate a single default test case
+        return [{
+            "id": f"TC-{iteration:02d}01",
+            "input_data": "Test with empty input",
+            "expected_behavior": "Should handle empty or minimal input gracefully",
+            "edge_case_type": "missing_data",
+            "difficulty": "medium",
+            "rationale": "Fallback test case due to parsing error",
+        }]
+
+
+def red_team_node(state: QAState) -> dict:
+    """
+    LangGraph node: Red-Team Agent.
+    
+    Generates adversarial test cases for the current iteration.
+    Uses failure patterns from previous iterations to create more targeted tests.
+    
+    Args:
+        state: Current QAState
+        
+    Returns:
+        State update with new test_suite entries and incremented iteration
+    """
+    iteration = state.get("current_iteration", 0) + 1
+    num_tests = int(os.getenv("TESTS_PER_ITERATION", "5"))
+    
+    print(f"\n{'='*60}")
+    print(f"🔴 RED-TEAM AGENT — Iteration {iteration}")
+    print(f"{'='*60}")
+    print(f"  Generating {num_tests} adversarial test cases...")
+    
+    # Build the prompt
+    failure_context = _build_failure_context(state)
+    
+    generation_prompt = RED_TEAM_GENERATION_PROMPT.format(
+        num_tests=num_tests,
+        sut_description=state.get("sut_description", "Financial Document RAG"),
+        domain=state.get("domain", "WAM financial documents"),
+        iteration=iteration,
+        iteration_prefix=f"{iteration:02d}",
+        failure_context=failure_context,
+    )
+    
+    # Call the LLM — format system prompt with domain context
+    llm = _get_llm()
+    system_prompt = RED_TEAM_SYSTEM_PROMPT.format(
+        sut_description=state.get("sut_description", "Unknown System"),
+        domain=state.get("domain", "general"),
+        sut_architecture=state.get("sut_architecture", "Architecture unknown. Treat as black-box.")
+    )
+    messages = [
+        SystemMessage(content=system_prompt),
+        HumanMessage(content=generation_prompt),
+    ]
+    
+    response = llm.invoke(messages)
+    
+    # Parse test cases from LLM response
+    test_cases = _parse_test_cases(response.content, iteration)
+    
+    print(f"  ✅ Generated {len(test_cases)} test cases:")
+    for tc in test_cases:
+        print(f"     [{tc['id']}] {tc['edge_case_type']:20s} | {tc['difficulty']:6s} | {tc['input_data'][:60]}...")
+    
+    return {
+        "test_suite": test_cases,
+        "current_iteration": iteration,
+    }