adding infill

app/domains/cars/config.py

@@ -1,10 +1,11 @@
 from app.domains.cars.schemas import CarData
-from app.domains.cars.prompts import create_prompt
+from app.domains.cars.prompts import create_prompt, create_infill_prompt
 
 # Domain-specific configuration for 'cars'
 domain_config = {
     "schema": CarData,
     "create_prompt": create_prompt,
+    "create_infill_prompt": create_infill_prompt,
     "mcp_rules": {
         "preprocessor": {
             # Add any car-specific preprocessing rules here

app/domains/cars/prompts.py

@@ -1,4 +1,5 @@
 from app.domains.cars.schemas import CarData
+from app.schemas.schemas import InfillOptions
 
 def create_prompt(car_data: CarData) -> list[dict]:
     """
@@ -28,3 +29,56 @@ Na podstawie poniższych danych, utwórz krótki, atrakcyjny opis marketingowy t
 """
         }
     ]
+
+
+def create_infill_prompt(text_with_gaps: str, options: InfillOptions) -> list[dict]:
+    """
+    Creates the chat prompt for gap-filling in car ads.
+    
+    The LLM must return strict JSON with filled text and per-gap choices.
+    
+    Args:
+        text_with_gaps: Ad text with [GAP:n] markers
+        options: InfillOptions with language, top_n_per_gap, etc.
+        
+    Returns:
+        Chat messages for the LLM
+    """
+    lang_instruction = "po polsku" if options.language == "pl" else "in English"
+    
+    system_content = f"""Jesteś ekspertem od uzupełniania tekstów ogłoszeń samochodowych.
+
+ZADANIE:
+Uzupełnij luki oznaczone jako [GAP:n] najbardziej naturalnymi słowami {lang_instruction}.
+Każda luka powinna być uzupełniona słowem lub krótką frazą (1-4 słowa).
+
+ZASADY:
+1. NIE zmieniaj żadnego tekstu poza lukami [GAP:n]
+2. Uzupełnienia muszą pasować kontekstowo i gramatycznie
+3. Używaj słownictwa typowego dla ogłoszeń motoryzacyjnych
+4. Dla każdej luki podaj {options.top_n_per_gap} alternatywnych propozycji
+
+WYMAGANY FORMAT ODPOWIEDZI (tylko JSON, bez komentarzy):
+{{
+    "filled_text": "Pełny tekst z uzupełnionymi lukami",
+    "gaps": [
+        {{
+            "index": 1,
+            "marker": "[GAP:1]",
+            "choice": "wybrane_słowo",
+            "alternatives": ["alt1", "alt2"]
+        }}
+    ]
+}}"""
+
+    user_content = f"""Uzupełnij luki w poniższym ogłoszeniu:
+
+{text_with_gaps}
+
+Odpowiedz TYLKO poprawnym JSON zgodnym z podanym formatem."""
+
+    return [
+        {"role": "system", "content": system_content},
+        {"role": "user", "content": user_content}
+    ]
+

app/logic/__init__.py

@@ -0,0 +1 @@
+# Logic module for MCP processing and utilities

app/logic/infill_utils.py

@@ -0,0 +1,233 @@
+"""
+Infill Utilities for Batch Gap-Filling
+
+Handles gap detection, JSON parsing from LLM output, and text reconstruction.
+
+Gap Notation Support:
+- [GAP:n]: Explicit numbered gaps (preferred)
+- ___: Underscores (auto-numbered in scan order)
+
+FUTURE: Chunking Support
+-------------------------
+For texts exceeding ~2000 tokens (approx 6000 chars), implement per-gap prompting:
+1. Split text into chunks preserving gap context (±150 tokens around each gap)
+2. Process each gap individually with left/right context
+3. Merge results back into full text
+4. This avoids context window overflow on smaller models (2k-4k context)
+
+Current implementation assumes texts fit within model context window.
+Add chunking when processing long-form content (articles, full listings).
+"""
+
+import re
+import json
+from typing import List, Optional, Tuple
+from dataclasses import dataclass
+
+
+@dataclass
+class GapInfo:
+    """Information about a detected gap in text."""
+    index: int          # 1-based index
+    marker: str         # Original marker string
+    start: int          # Start position in text
+    end: int            # End position in text
+
+
+def detect_gaps(text: str, notation: str = "auto") -> List[GapInfo]:
+    """
+    Detect gaps in text and return their positions.
+    
+    Args:
+        text: Input text with gap markers
+        notation: "auto", "[GAP:n]", or "___"
+        
+    Returns:
+        List of GapInfo objects sorted by position
+        
+    Examples:
+        >>> detect_gaps("Buy this [GAP:1] car with [GAP:2] features")
+        [GapInfo(index=1, marker='[GAP:1]', ...), GapInfo(index=2, marker='[GAP:2]', ...)]
+        
+        >>> detect_gaps("Buy this ___ car with ___ features")
+        [GapInfo(index=1, marker='___', ...), GapInfo(index=2, marker='___', ...)]
+    """
+    gaps = []
+    
+    # Pattern for [GAP:n] notation
+    gap_tag_pattern = r'\[GAP:(\d+)\]'
+    # Pattern for underscore notation (3+ underscores)
+    underscore_pattern = r'_{3,}'
+    
+    if notation == "auto":
+        # Try [GAP:n] first, fallback to ___
+        gap_matches = list(re.finditer(gap_tag_pattern, text))
+        if gap_matches:
+            notation = "[GAP:n]"
+        else:
+            notation = "___"
+    
+    if notation == "[GAP:n]":
+        for match in re.finditer(gap_tag_pattern, text):
+            gaps.append(GapInfo(
+                index=int(match.group(1)),
+                marker=match.group(0),
+                start=match.start(),
+                end=match.end()
+            ))
+    else:  # "___"
+        for i, match in enumerate(re.finditer(underscore_pattern, text), start=1):
+            gaps.append(GapInfo(
+                index=i,
+                marker=match.group(0),
+                start=match.start(),
+                end=match.end()
+            ))
+    
+    # Sort by position (should already be, but ensure)
+    gaps.sort(key=lambda g: g.start)
+    return gaps
+
+
+def parse_infill_json(raw_output: str) -> Optional[dict]:
+    """
+    Extract and parse JSON from LLM output.
+    
+    Handles common LLM quirks:
+    - JSON wrapped in markdown code blocks
+    - Leading/trailing text before/after JSON
+    - Minor formatting issues
+    
+    Args:
+        raw_output: Raw text from LLM
+        
+    Returns:
+        Parsed dict with 'filled_text' and 'gaps' keys, or None if parsing fails
+        
+    Expected JSON format:
+    {
+        "filled_text": "Complete text with gaps filled",
+        "gaps": [
+            {"index": 1, "marker": "[GAP:1]", "choice": "word", "alternatives": ["alt1", "alt2"]}
+        ]
+    }
+    """
+    if not raw_output:
+        return None
+    
+    # Try to extract JSON from markdown code blocks
+    json_block_pattern = r'```(?:json)?\s*([\s\S]*?)\s*```'
+    match = re.search(json_block_pattern, raw_output)
+    if match:
+        raw_output = match.group(1)
+    
+    # Try to find JSON object boundaries
+    # Look for the outermost { }
+    start_idx = raw_output.find('{')
+    if start_idx == -1:
+        return None
+    
+    # Find matching closing brace
+    depth = 0
+    end_idx = -1
+    for i, char in enumerate(raw_output[start_idx:], start=start_idx):
+        if char == '{':
+            depth += 1
+        elif char == '}':
+            depth -= 1
+            if depth == 0:
+                end_idx = i + 1
+                break
+    
+    if end_idx == -1:
+        return None
+    
+    json_str = raw_output[start_idx:end_idx]
+    
+    try:
+        parsed = json.loads(json_str)
+        
+        # Validate required fields
+        if 'filled_text' not in parsed and 'gaps' not in parsed:
+            return None
+            
+        return parsed
+    except json.JSONDecodeError:
+        return None
+
+
+def apply_fills(original_text: str, gaps: List[GapInfo], fills: dict) -> str:
+    """
+    Apply gap fills to original text.
+    
+    Uses fills from parsed JSON, replacing markers with chosen words.
+    This is a fallback when LLM's 'filled_text' might be corrupted.
+    
+    Args:
+        original_text: Original text with gap markers
+        gaps: Detected gaps from detect_gaps()
+        fills: Dict mapping gap index to fill choice
+               e.g., {1: "excellent", 2: "powerful"}
+               
+    Returns:
+        Text with gaps replaced by fill choices
+    """
+    if not gaps or not fills:
+        return original_text
+    
+    # Process from end to start to preserve positions
+    result = original_text
+    for gap in reversed(gaps):
+        if gap.index in fills:
+            result = result[:gap.start] + fills[gap.index] + result[gap.end:]
+    
+    return result
+
+
+def build_fills_dict(gaps_list: List[dict]) -> dict:
+    """
+    Convert gaps list from JSON to fills dict.
+    
+    Args:
+        gaps_list: List of gap dicts from parsed JSON
+                   [{"index": 1, "choice": "word"}, ...]
+                   
+    Returns:
+        Dict mapping index to choice: {1: "word", ...}
+    """
+    fills = {}
+    for gap in gaps_list:
+        if 'index' in gap and 'choice' in gap:
+            fills[gap['index']] = gap['choice']
+    return fills
+
+
+def normalize_gaps_to_tagged(text: str) -> Tuple[str, List[GapInfo]]:
+    """
+    Normalize any gap notation to [GAP:n] format.
+    
+    Useful for standardizing input before processing.
+    
+    Args:
+        text: Text with any gap notation
+        
+    Returns:
+        Tuple of (normalized_text, gaps)
+    """
+    gaps = detect_gaps(text, "auto")
+    
+    if not gaps:
+        return text, []
+    
+    # If already [GAP:n], return as-is
+    if gaps[0].marker.startswith('[GAP:'):
+        return text, gaps
+    
+    # Convert ___ to [GAP:n]
+    result = text
+    for gap in reversed(gaps):
+        new_marker = f"[GAP:{gap.index}]"
+        result = result[:gap.start] + new_marker + result[gap.end:]
+    
+    # Re-detect with new positions
+    return result, detect_gaps(result, "[GAP:n]")

app/main.py

@@ -14,6 +14,20 @@ from app.schemas.schemas import (
     CompareResponse,
     ModelResult,
     ModelInfo,
+    InfillRequest,
+    InfillResponse,
+    InfillResult,
+    GapFill,
+    CompareInfillRequest,
+    CompareInfillResponse,
+    ModelInfillResult,
+)
+from app.logic.infill_utils import (
+    detect_gaps,
+    parse_infill_json,
+    apply_fills,
+    build_fills_dict,
+    normalize_gaps_to_tagged,
 )
 from app.auth.placeholder_auth import get_authenticated_user
 
@@ -245,4 +259,210 @@ async def get_user_info(user: dict = Depends(get_authenticated_user)):
         "user_id": user['user_id'],
         "email": user['email'],
         "name": user.get('name', 'Unknown')
-    }
+    }
+
+
+# --- Batch Infill Endpoints ---
+
+@app.post("/infill", response_model=InfillResponse)
+async def batch_infill(
+    request: InfillRequest,
+    user: Optional[dict] = Depends(get_authenticated_user)
+):
+    """
+    Batch gap-filling for ads using a single model.
+    
+    Accepts items with [GAP:n] markers or ___ and returns filled text
+    with per-gap choices and alternatives.
+    
+    NOTE: For texts > 6000 chars, consider chunking (not yet implemented).
+    """
+    total_start = time.time()
+    
+    # Validate model
+    if request.model not in registry.get_available_model_names():
+        raise HTTPException(status_code=400, detail=f"Unknown model: {request.model}")
+    
+    # Load domain config for infill prompt
+    domain_config = get_domain_config(request.domain)
+    if "create_infill_prompt" not in domain_config:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Domain '{request.domain}' does not support infill operations"
+        )
+    create_infill_prompt = domain_config["create_infill_prompt"]
+    
+    # Process each item
+    results = []
+    error_count = 0
+    
+    for item in request.items:
+        result = await process_infill_item(
+            item=item,
+            model_name=request.model,
+            options=request.options,
+            create_infill_prompt=create_infill_prompt
+        )
+        results.append(result)
+        if result.status == "error":
+            error_count += 1
+    
+    return InfillResponse(
+        model=request.model,
+        results=results,
+        total_time=round(time.time() - total_start, 2),
+        processed_count=len(results),
+        error_count=error_count
+    )
+
+
+@app.post("/compare-infill", response_model=CompareInfillResponse)
+async def compare_infill(
+    request: CompareInfillRequest,
+    user: Optional[dict] = Depends(get_authenticated_user)
+):
+    """
+    Multi-model batch gap-filling comparison for A/B testing.
+    
+    Runs the same batch of items through multiple models and returns
+    per-model results for comparison.
+    """
+    total_start = time.time()
+    
+    # Get models to compare
+    available_models = registry.get_available_model_names()
+    models_to_use = request.models if request.models else available_models
+    
+    # Validate requested models
+    for model in models_to_use:
+        if model not in available_models:
+            raise HTTPException(status_code=400, detail=f"Unknown model: {model}")
+    
+    # Load domain config
+    domain_config = get_domain_config(request.domain)
+    if "create_infill_prompt" not in domain_config:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Domain '{request.domain}' does not support infill operations"
+        )
+    create_infill_prompt = domain_config["create_infill_prompt"]
+    
+    # Process with each model (sequentially for memory safety)
+    model_results = []
+    
+    for model_name in models_to_use:
+        model_start = time.time()
+        results = []
+        error_count = 0
+        
+        for item in request.items:
+            result = await process_infill_item(
+                item=item,
+                model_name=model_name,
+                options=request.options,
+                create_infill_prompt=create_infill_prompt
+            )
+            results.append(result)
+            if result.status == "error":
+                error_count += 1
+        
+        model_results.append(ModelInfillResult(
+            model=model_name,
+            type=MODEL_CONFIG[model_name]["type"],
+            results=results,
+            time=round(time.time() - model_start, 2),
+            error_count=error_count
+        ))
+    
+    return CompareInfillResponse(
+        domain=request.domain,
+        models=model_results,
+        total_time=round(time.time() - total_start, 2)
+    )
+
+
+async def process_infill_item(
+    item,
+    model_name: str,
+    options,
+    create_infill_prompt
+) -> InfillResult:
+    """
+    Process a single infill item.
+    
+    Returns InfillResult with status, filled_text, and gaps.
+    """
+    try:
+        # Normalize gaps to [GAP:n] format
+        normalized_text, gaps = normalize_gaps_to_tagged(item.text_with_gaps)
+        
+        if not gaps:
+            # No gaps found, return original text
+            return InfillResult(
+                id=item.id,
+                status="ok",
+                filled_text=item.text_with_gaps,
+                gaps=[],
+                error=None
+            )
+        
+        # Build prompt
+        chat_messages = create_infill_prompt(normalized_text, options)
+        
+        # Generate
+        llm = await registry.get_model(model_name)
+        raw_output = await llm.generate(
+            chat_messages=chat_messages,
+            max_new_tokens=options.max_new_tokens,
+            temperature=options.temperature,
+            top_p=0.9,
+        )
+        
+        # Parse JSON from output
+        parsed = parse_infill_json(raw_output)
+        
+        if not parsed:
+            # JSON parsing failed
+            return InfillResult(
+                id=item.id,
+                status="error",
+                filled_text=None,
+                gaps=[],
+                error=f"Failed to parse JSON from model output: {raw_output[:200]}..."
+            )
+        
+        # Extract gaps and build result
+        gap_fills = []
+        fills_dict = {}
+        
+        for gap_data in parsed.get("gaps", []):
+            gap_fill = GapFill(
+                index=gap_data.get("index", 0),
+                marker=gap_data.get("marker", ""),
+                choice=gap_data.get("choice", ""),
+                alternatives=gap_data.get("alternatives", [])
+            )
+            gap_fills.append(gap_fill)
+            fills_dict[gap_fill.index] = gap_fill.choice
+        
+        # Get filled text - prefer model's version, fallback to reconstruction
+        filled_text = parsed.get("filled_text")
+        if not filled_text and fills_dict:
+            filled_text = apply_fills(normalized_text, gaps, fills_dict)
+        
+        return InfillResult(
+            id=item.id,
+            status="ok",
+            filled_text=filled_text,
+            gaps=gap_fills,
+            error=None
+        )
+        
+    except Exception as e:
+        return InfillResult(
+            id=item.id,
+            status="error",
+            filled_text=None,
+            gaps=[],
+            error=str(e)
+        )

app/schemas/schemas.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from typing import List, Optional, Dict, Any
 
 
@@ -9,6 +9,95 @@ class EnhancedDescriptionResponse(BaseModel):
     user_email: str
 
 
+# --- Batch Infill Schemas ---
+
+class InfillItem(BaseModel):
+    """A single item (ad) with gaps to be filled."""
+    id: str = Field(..., description="Unique identifier for this item")
+    text_with_gaps: str = Field(..., description="Text containing [GAP:n] markers or ___ to fill")
+
+
+class InfillOptions(BaseModel):
+    """Configuration options for infill processing."""
+    gap_notation: str = Field(
+        default="auto",
+        description="Gap notation: 'auto' (detect), '[GAP:n]', or '___'"
+    )
+    top_n_per_gap: int = Field(
+        default=3,
+        ge=1,
+        le=5,
+        description="Number of alternative suggestions per gap (1-5)"
+    )
+    language: str = Field(default="pl", description="Output language (pl/en)")
+    temperature: float = Field(default=0.6, ge=0.0, le=1.0)
+    max_new_tokens: int = Field(default=256, ge=50, le=512)
+
+
+class GapFill(BaseModel):
+    """Result for a single filled gap."""
+    index: int = Field(..., description="Gap index (1-based)")
+    marker: str = Field(..., description="Original marker (e.g., '[GAP:1]' or '___')")
+    choice: str = Field(..., description="Selected fill word/phrase")
+    alternatives: List[str] = Field(
+        default_factory=list,
+        description="Alternative suggestions"
+    )
+
+
+class InfillResult(BaseModel):
+    """Result for a single infill item."""
+    id: str
+    status: str = Field(..., description="'ok' or 'error'")
+    filled_text: Optional[str] = Field(None, description="Text with gaps filled")
+    gaps: List[GapFill] = Field(default_factory=list)
+    error: Optional[str] = Field(None, description="Error message if status='error'")
+
+
+class InfillRequest(BaseModel):
+    """Request for single-model batch infill."""
+    domain: str = Field(..., description="Domain name (e.g., 'cars')")
+    items: List[InfillItem] = Field(..., description="Batch of items to process")
+    model: str = Field(default="bielik-1.5b", description="Model to use")
+    options: InfillOptions = Field(default_factory=InfillOptions)
+
+
+class InfillResponse(BaseModel):
+    """Response for single-model batch infill."""
+    model: str
+    results: List[InfillResult]
+    total_time: float
+    processed_count: int
+    error_count: int
+
+
+class CompareInfillRequest(BaseModel):
+    """Request for multi-model batch infill comparison."""
+    domain: str
+    items: List[InfillItem]
+    models: Optional[List[str]] = Field(
+        None,
+        description="Models to compare. If None, use all available."
+    )
+    options: InfillOptions = Field(default_factory=InfillOptions)
+
+
+class ModelInfillResult(BaseModel):
+    """Per-model results in comparison."""
+    model: str
+    type: str
+    results: List[InfillResult]
+    time: float
+    error_count: int
+
+
+class CompareInfillResponse(BaseModel):
+    """Response for multi-model batch infill comparison."""
+    domain: str
+    models: List[ModelInfillResult]
+    total_time: float
+
+
 class ModelInfo(BaseModel):
     name: str
     model_id: str