Function bodies 269 total

async def lifespan(app: FastAPI):
    global _semaphore
    _semaphore = asyncio.Semaphore(MAX_CONCURRENT)
    log.info("Browser service starting — max concurrent sessions: %d", MAX_CONCURRENT)
    yield
    log.info("Browser service shutting down")

class BrowseRequest(BaseModel):
    """A single browsing task dispatched by a Java agent."""
    task: str = Field(..., description="Natural language task for the browser agent to perform")
    sites: list[str] = Field(default=[], description="Seed URLs to start from (optional)")
    extraction_schema: Optional[str] = Field(
        None,
        description="JSON schema hint for the extracted data (e.g. 'return a JSON array of {name, pricePerNight, ...}')"
    )
    model: Optional[str] = Field(None, description="LLM model override, e.g. 'anthropic/claude-3-5-sonnet-20241022'")
    max_steps: int = Field(default=15, description="Max browser steps before giving up")
    timeout_seconds: int = Field(default=120, description="Timeout for the whole browsing session")

class BrowseResponse(BaseModel):
    success: bool
    result: Any  # parsed JSON or raw text
    raw_text: Optional[str] = None
    steps_taken: int = 0
    duration_seconds: float = 0.0
    error: Optional[str] = None

class HealthResponse(BaseModel):
    status: str
    max_concurrent: int
    active_sessions: int
    default_model: str

def build_llm(model_string: Optional[str]):
    """Resolve a provider/model string to a LangChain chat model."""
    model_string = model_string or DEFAULT_MODEL

    if model_string.startswith("anthropic/"):
        model_name = model_string.split("/", 1)[1]
        # Map shorthand → versioned model
        model_map = {
            "claude-3-5-sonnet": "claude-3-5-sonnet-20241022",
            "claude-3-haiku": "claude-3-haiku-20240307",
            "claude-3-opus": "claude-3-opus-20240229",
            "claude-sonnet-4": "claude-sonnet-4-5",
            "claude-opus-4": "claude-opus-4-5",
        }
        resolved = model_map.get(model_name, model_name)
        return ChatAnthropic(
            model=resolved,
            api_key=ANTHROPIC_API_KEY,
            timeout=90,
            max_tokens=4096,
        )

    if model_string.startswith("openai/"):
        model_name = model_string.split("/", 1)[1]
        return ChatOpenAI(model=model_name, api_key=OPENAI_API_KEY, timeout=90)

def parse_result(raw: str) -> Any:
    """Try to parse the agent output as JSON; fall back to raw string."""
    import json
    import re

    # Strip markdown fences
    cleaned = re.sub(r"```(?:json)?\s*", "", raw).strip().rstrip("```").strip()

    # Try full JSON parse
    try:
        return json.loads(cleaned)
    except json.JSONDecodeError:
        pass

    # Try extracting the first JSON array or object
    for pattern in (r"(\[.*?\])", r"(\{.*?\})"):
        match = re.search(pattern, cleaned, re.DOTALL)
        if match:
            try:
                return json.loads(match.group(1))
            except json.JSONDecodeError:
                pass

    return raw  # return as plain text if JSON parsing fails

async def health():
    return HealthResponse(
        status="ok",
        max_concurrent=MAX_CONCURRENT,
        active_sessions=_active_sessions,
        default_model=DEFAULT_MODEL,
    )

async def browse(req: BrowseRequest):
    """
    Dispatch a browser-use agent to perform a real web search/extraction task.
    Blocks until the task completes (or times out).
    """
    global _active_sessions

    async with _semaphore:
        _active_sessions += 1
        start = time.time()
        try:
            llm = build_llm(req.model)

            # Build the full task description
            full_task = req.task
            if req.extraction_schema:
                full_task += f"\n\nReturn the result as: {req.extraction_schema}"
            if req.sites:
                full_task += f"\n\nStart by visiting these sites: {', '.join(req.sites)}"
            full_task += "\nReturn ONLY valid JSON, no markdown, no explanation."

            browser_cfg = BrowserConfig(headless=BROWSER_HEADLESS)
            browser = Browser(config=browser_cfg)
            try:
                agent = BrowserAgent(
                    task=full_task,
                    llm=llm,
             

async def browse_batch(requests: list[BrowseRequest]):
    """
    Submit multiple browsing tasks at once. They run concurrently (up to MAX_CONCURRENT).
    Useful when a single agent wants to search multiple sites in parallel.
    """
    tasks = [browse(req) for req in requests]
    return await asyncio.gather(*tasks)

function App() {
  const [itinerary, setItinerary]   = useState(null);
  const [agents, setAgents]         = useState(INITIAL_AGENTS);
  const [isLoading, setIsLoading]   = useState(false);
  const [error, setError]           = useState(null);
  const [activeView, setActiveView] = useState('planner');  // 'planner' | 'admin'
  const eventSourceRef              = useRef(null);

  const updateAgent = useCallback((name, status, progress) => {
    setAgents(prev => prev.map(a =>
      a.name === name ? { ...a, status, progress } : a
    ));
  }, []);

  const closeEventSource = () => {
    if (eventSourceRef.current) {
      eventSourceRef.current.close();
      eventSourceRef.current = null;
    }
  };

  const handlePlanTrip = async (travelRequest) => {
    setIsLoading(true);
    setItinerary(null);
    setError(null);
    setAgents(INITIAL_AGENTS);
    closeEventSource();

    const sessionId = `sess-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;

    // Open SSE stream firs

function AdminDashboard() {
  const [activeTab, setActiveTab] = useState('prompts');
  const [prompts, setPrompts] = useState([]);
  const [costs, setCosts] = useState(null);
  const [targets, setTargets] = useState([]);
  const [editingPrompt, setEditingPrompt] = useState(null);
  const [editText, setEditText] = useState('');
  const [loading, setLoading] = useState(false);
  const [adminToken, setAdminToken] = useState(localStorage.getItem('matoe-admin-token') || '');

  const authHeaders = (extra = {}) => ({
    'Content-Type': 'application/json',
    ...(adminToken ? { 'X-Admin-Token': adminToken } : {}),
    ...extra,
  });

  const handleTokenChange = (e) => {
    const val = e.target.value;
    setAdminToken(val);
    localStorage.setItem('matoe-admin-token', val);
  };

  const fetchPrompts = useCallback(async () => {
    try {
      const res = await fetch('/api/admin/prompts');
      const data = await res.json();
      setPrompts(data.prompts || []);
    } catch (err) { cons

function ItineraryCanvas({ itinerary }) {
  const [expandedSection, setExpandedSection] = useState('variants');
  const [compareMode, setCompareMode] = useState(false);
  const [selectedVariant, setSelectedVariant] = useState(null);

  const handleDownload = () => {
    const blob = new Blob([JSON.stringify(itinerary, null, 2)], { type: 'application/json' });
    const url = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = url;
    a.download = `matoe-itinerary-${itinerary.destination.replace(/\s+/g, '-').toLowerCase()}-${itinerary.id}.json`;
    document.body.appendChild(a);
    a.click();
    document.body.removeChild(a);
    URL.revokeObjectURL(url);
  };

  // PDF export — calls the backend endpoint so that rendering (layout, fonts,
  // synthetic warnings) stays consistent across clients. The backend serves
  // application/pdf with Content-Disposition: attachment, so we just navigate
  // the browser to the URL and let it download.
  const handle

function AccommodationCard({ acc }) {
  return (
    <div className={`option-card ${acc.tier}`}>
      <div className="card-header">
        <h4>{acc.name}</h4>
        <span className="tier-badge">{acc.tier}</span>
      </div>
      <p className="location">{acc.location}</p>
      <div className="details">
        <span className="rating">★ {acc.rating}</span>
        <span className="price">&euro;{acc.pricePerNight}/night</span>
      </div>
      <p className="amenities">{acc.amenities && acc.amenities.join(', ')}</p>
      {acc.source && <span className="source-badge">{acc.source}</span>}
      {acc.source === 'llm' && <span className="synthetic-warning">AI-generated estimate</span>}
      {acc.bookingUrl && acc.source !== 'llm' && (
        <a href={acc.bookingUrl} target="_blank" rel="noopener noreferrer" className="book-btn">Book &rarr;</a>
      )}
    </div>
  );
}

function TransportCard({ t }) {
  const icons = { flight: '✈', car: '🚗', bus: '🚌', train: '🚆', ferry: '⛴' };
  return (
    <div className={`option-card ${t.tier}`}>
      <div className="card-header">
        <h4>{t.provider}</h4>
        <span className="tier-badge">{t.tier}</span>
      </div>
      <p className="type">{icons[t.type] || '🚗'} {t.type}</p>
      <div className="details">
        <span>{t.departureTime} &rarr; {t.arrivalTime}</span>
        <span>Duration: {t.duration}</span>
      </div>
      {t.stops > 0 && <p className="stops">{t.stops} stop(s)</p>}
      <div className="price">&euro;{t.price}</div>
      {t.source && <span className="source-badge">{t.source}</span>}
      {t.source === 'llm' && <span className="synthetic-warning">AI-generated estimate</span>}
      {t.bookingUrl && t.source !== 'llm' && (
        <a href={t.bookingUrl} target="_blank" rel="noopener noreferrer" className="book-btn">Book &rarr;</a>
      )}
    </div>
  );
}

function LiveAgentTracker({ agents, isLoading }) {
  const getStatusEmoji = (status) => {
    switch (status) {
      case 'idle':
        return '💤';
      case 'deployed':
        return '🚀';
      case 'searching':
        return '🔍';
      case 'analyzing':
        return '🧠';
      case 'completed':
        return '✅';
      case 'error':
        return '❌';
      default:
        return '⏳';
    }
  };

  const getStatusColor = (status) => {
    switch (status) {
      case 'idle':
        return '#555';
      case 'deployed':
        return '#ffc107';
      case 'searching':
        return '#2196f3';
      case 'analyzing':
        return '#9c27b0';
      case 'completed':
        return '#4caf50';
      case 'error':
        return '#f44336';
      default:
        return '#999';
    }
  };

  return (
    <div className="live-tracker">
      <h2>📊 Live Agent Tracker</h2>

      {!isLoading && agents.length === 0 ? (
        <div className="tracker-empty">
          <p>Agents w

function MissionControl({ onPlanTrip, isLoading }) {
  const [formData, setFormData] = useState({
    destination: '',
    originCity: '',
    startDate: '',
    endDate: '',
    guestCount: 1,
    budgetMin: 1000,
    budgetMax: 5000,
    travelStyle: 'standard',
    accommodationTypes: ['hotel', 'bb', 'apartment'],
    transportTypes: ['flight', 'car'],
    interestTags: [],
    orchestratorModel: 'anthropic/claude-3-5-sonnet',
    extractorModel: 'lmstudio/llama-3-8b',
  });

  const handleInputChange = (e) => {
    const { name, value, type, checked } = e.target;

    if (type === 'checkbox') {
      const fieldName = name.replace('_', '');
      setFormData((prev) => ({
        ...prev,
        [fieldName]: checked
          ? [...prev[fieldName], value]
          : prev[fieldName].filter((item) => item !== value),
      }));
    } else {
      setFormData((prev) => ({
        ...prev,
        [name]: value,
      }));
    }
  };

  const handleSubmit = (e) => {
    e.preventDefau

public class ApartmentAgent {

    private static final Logger log = LoggerFactory.getLogger(ApartmentAgent.class);

    private final BrowserAgentService browserService;
    private final LlmService llmService;
    private final ObjectMapper objectMapper;
    private final PromptTemplateService promptTemplateService;
    private final DynamicPromptService dynamicPromptService;
    private final LlmCostTrackingService costTracker;
    private final SearchTargetService searchTargetService;

    @Value("${travel-agency.prompts.apartment-agent}")
    private String defaultPrompt;

    @Value("${travel-agency.browser.apartment-sites:airbnb.com,vrbo.com,booking.com}")
    private String apartmentSites;

    public ApartmentAgent(BrowserAgentService browserService, LlmService llmService,
                          ObjectMapper objectMapper, PromptTemplateService promptTemplateService,
                          DynamicPromptService dynamicPromptService, LlmCostTrackingService costTracker,
    

    public ApartmentAgent(BrowserAgentService browserService, LlmService llmService,
                          ObjectMapper objectMapper, PromptTemplateService promptTemplateService,
                          DynamicPromptService dynamicPromptService, LlmCostTrackingService costTracker,
                          SearchTargetService searchTargetService) {
        this.browserService = browserService;
        this.llmService = llmService;
        this.objectMapper = objectMapper;
        this.promptTemplateService = promptTemplateService;
        this.dynamicPromptService = dynamicPromptService;
        this.costTracker = costTracker;
        this.searchTargetService = searchTargetService;
        // Register YAML default (DB version will override if set by admin)
        dynamicPromptService.registerDefault("apartment-agent", "");
    }

    void init() {
        dynamicPromptService.registerDefault("apartment-agent", defaultPrompt);
    }

    public List<AccommodationOption> searchApartments(TravelRequest request) {
        long nights = request.nights();
        String model = request.extractorModel();
        int bedroomsNeeded = Math.max(1, request.guestCount() / 2);

        // ── primary: real browser search ─────────────────────────────────────
        if (browserService.isAvailable()) {
            try {
                List<Map<String, Object>> raw = browserService.browseForList(
                    buildBrowserTask(request, nights, bedroomsNeeded),
                    searchTargetService.getSites("apartment-agent", apartmentSites),
                    "a JSON array of apartment objects each with: name, pricePerNight (number), " +
                    "totalPrice (number), rating (number 1-5), location (string), " +
                    "amenities (array of strings), bookingUrl (string)",
                    model
                );
                if (raw != null && !raw.isEmpty()) {
                    log.info(

    private String buildBrowserTask(TravelRequest request, long nights, int bedroomsNeeded) {
        return String.format(
            "Find 3-5 holiday apartments or short-term rentals in %s for %d guests (%d+ bedrooms needed), " +
            "check-in %s, check-out %s (%d nights). " +
            "Budget: \u20ac%.0f\u2013\u20ac%.0f total. Travel style: %s. " +
            "For each get: name, price per night, total price, rating, neighborhood, amenities, booking URL.",
            request.destination(), request.guestCount(), bedroomsNeeded,
            request.startDate(), request.endDate(), nights,
            request.budgetMin(), request.budgetMax(), request.travelStyle()
        );
    }

    private AccommodationOption map(Map<String, Object> m, long nights, String source) {
        double ppn  = num(m, "pricePerNight");
        double tot  = num(m, "totalPrice", ppn * nights);
        double avgPpn = nights > 0 ? tot / nights : ppn;
        String tier = avgPpn < 100 ? "budget" : avgPpn > 250 ? "luxury" : "standard";
        return new AccommodationOption(
            UUID.randomUUID().toString(), "apartment", str(m, "name"), ppn, tot,
            num(m, "rating"), str(m, "location"), toStringList(m.get("amenities")),
            str(m, "bookingUrl"), tier, source, str(m, "imageUrl")
        );
    }

    private List<String> toStringList(Object v) {
        if (v instanceof List<?> l) return l.stream().map(Object::toString).collect(Collectors.toList());
        return List.of(); }

    private String resolveProvider(String model) {
        if (model == null) return "anthropic";
        if (model.startsWith("anthropic/")) return "anthropic";
        if (model.startsWith("lmstudio/")) return "lmstudio";
        if (model.startsWith("ollama/")) return "ollama";
        if (model.startsWith("openrouter/")) return "openrouter";
        return "unknown";
    }

public class AttractionsAgent {

    private static final Logger log = LoggerFactory.getLogger(AttractionsAgent.class);

    private final BrowserAgentService browserService;
    private final LlmService llmService;
    private final ObjectMapper objectMapper;
    private final PromptTemplateService promptTemplateService;
    private final DynamicPromptService dynamicPromptService;
    private final LlmCostTrackingService costTracker;
    private final SearchTargetService searchTargetService;

    @Value("${travel-agency.prompts.attractions-agent}")
    private String defaultPrompt;

    @Value("${travel-agency.browser.attraction-sites:viator.com,getyourguide.com,tripadvisor.com}")
    private String attractionSites;

    public AttractionsAgent(BrowserAgentService browserService, LlmService llmService,
                            ObjectMapper objectMapper, PromptTemplateService promptTemplateService,
                            DynamicPromptService dynamicPromptService, LlmCostTrackin

    public AttractionsAgent(BrowserAgentService browserService, LlmService llmService,
                            ObjectMapper objectMapper, PromptTemplateService promptTemplateService,
                            DynamicPromptService dynamicPromptService, LlmCostTrackingService costTracker,
                            SearchTargetService searchTargetService) {
        this.browserService = browserService;
        this.llmService = llmService;
        this.objectMapper = objectMapper;
        this.promptTemplateService = promptTemplateService;
        this.dynamicPromptService = dynamicPromptService;
        this.costTracker = costTracker;
        this.searchTargetService = searchTargetService;
    }

    void init() {
        dynamicPromptService.registerDefault("attractions-agent", defaultPrompt);
    }

    public List<AttractionOption> searchAttractions(TravelRequest request) {
        String model = request.extractorModel();
        String interestTags = request.interestTags() != null && !request.interestTags().isEmpty()
            ? String.join(", ", request.interestTags())
            : "general sightseeing";

        // ── primary: real browser search ─────────────────────────────────────
        if (browserService.isAvailable()) {
            try {
                List<Map<String, Object>> raw = browserService.browseForList(
                    buildBrowserTask(request, interestTags),
                    searchTargetService.getSites("attractions-agent", attractionSites),
                    "a JSON array of attraction objects each with: name, description, category, " +
                    "price (number in USD), duration (string like '2h' or 'half-day'), " +
                    "rating (number 1-5), location (string), bookingUrl (string), tags (array of strings)",
             

    private String buildBrowserTask(TravelRequest request, String interestTags) {
        return String.format(
            "Search for 6-8 attractions, tours, and activities in %s for %d guests, " +
            "visiting from %s to %s. Budget: $%.0f-$%.0f total. Travel style: %s. " +
            "Interests: %s. " +
            "For each attraction get: name, description, category, price per person, duration, " +
            "rating, location/neighborhood, booking URL, and relevant tags.",
            request.destination(), request.guestCount(),
            request.startDate(), request.endDate(),
            request.budgetMin(), request.budgetMax(), request.travelStyle(),
            interestTags
        );
    }

    private AttractionOption mapAttraction(Map<String, Object> m, String source) {
        double price = num(m, "price");
        String tier = price < 30 ? "budget" : price > 100 ? "luxury" : "standard";
        return new AttractionOption(
            UUID.randomUUID().toString(),
            str(m, "name"),
            str(m, "description"),
            str(m, "category"),
            price,
            str(m, "duration"),
            num(m, "rating"),
            str(m, "location"),
            str(m, "bookingUrl"),
            tier,
            source,
            toStringList(m.get("tags"))
        );
    }

    private List<String> toStringList(Object v) {
        if (v instanceof List<?> l) return l.stream().map(Object::toString).collect(Collectors.toList());
        return List.of(); }

    private String resolveProvider(String model) {
        if (model == null) return "anthropic";
        if (model.startsWith("anthropic/")) return "anthropic";
        if (model.startsWith("lmstudio/")) return "lmstudio";
        if (model.startsWith("ollama/")) return "ollama";
        if (model.startsWith("openrouter/")) return "openrouter";
        return "unknown";
    }

public class BBAgent {

    private static final Logger log = LoggerFactory.getLogger(BBAgent.class);

    private final BrowserAgentService browserService;
    private final LlmService llmService;
    private final ObjectMapper objectMapper;
    private final PromptTemplateService promptTemplateService;
    private final DynamicPromptService dynamicPromptService;
    private final LlmCostTrackingService costTracker;
    private final SearchTargetService searchTargetService;

    @Value("${travel-agency.prompts.bb-agent}")
    private String defaultPrompt;

    @Value("${travel-agency.browser.bb-sites:booking.com,airbnb.com,bedandbreakfast.com}")
    private String bbSites;

    public BBAgent(BrowserAgentService browserService, LlmService llmService,
                   ObjectMapper objectMapper, PromptTemplateService promptTemplateService,
                   DynamicPromptService dynamicPromptService, LlmCostTrackingService costTracker,
                   SearchTargetService searchTarg

    public BBAgent(BrowserAgentService browserService, LlmService llmService,
                   ObjectMapper objectMapper, PromptTemplateService promptTemplateService,
                   DynamicPromptService dynamicPromptService, LlmCostTrackingService costTracker,
                   SearchTargetService searchTargetService) {
        this.browserService = browserService;
        this.llmService = llmService;
        this.objectMapper = objectMapper;
        this.promptTemplateService = promptTemplateService;
        this.dynamicPromptService = dynamicPromptService;
        this.costTracker = costTracker;
        this.searchTargetService = searchTargetService;
        // Register YAML default (DB version will override if set by admin)
        dynamicPromptService.registerDefault("bb-agent", "");
    }

    void init() {
        dynamicPromptService.registerDefault("bb-agent", defaultPrompt);
    }

    public List<AccommodationOption> searchBBs(TravelRequest request) {
        long nights = request.nights();
        String model = request.extractorModel();

        // ── primary: real browser search ─────────────────────────────────────
        if (browserService.isAvailable()) {
            try {
                List<Map<String, Object>> raw = browserService.browseForList(
                    buildBrowserTask(request, nights),
                    searchTargetService.getSites("bb-agent", bbSites),
                    "a JSON array of B&B objects each with: name, pricePerNight (number), " +
                    "totalPrice (number), rating (number 1-5), location (string), " +
                    "amenities (array of strings), bookingUrl (string)",
                    model
                );
                if (raw != null && !raw.isEmpty()) {
                    log.info("BBAgent: {} results via browser for {}", raw.size(), request.destination());
                    return raw.st

    private String buildBrowserTask(TravelRequest request, long nights) {
        return String.format(
            "Find 3-5 bed-and-breakfasts or charming guesthouses in %s for %d guests, " +
            "check-in %s, check-out %s (%d nights). " +
            "Budget: \u20ac%.0f\u2013\u20ac%.0f total. Travel style: %s. " +
            "For each get: name, price per night, total price, rating, neighborhood, amenities, booking URL.",
            request.destination(), request.guestCount(),
            request.startDate(), request.endDate(), nights,
            request.budgetMin(), request.budgetMax(), request.travelStyle()
        );
    }

    private AccommodationOption map(Map<String, Object> m, long nights, String source) {
        double ppn  = num(m, "pricePerNight");
        double tot  = num(m, "totalPrice", ppn * nights);
        double avgPpn = nights > 0 ? tot / nights : ppn;
        String tier = avgPpn < 80 ? "budget" : avgPpn > 200 ? "luxury" : "standard";
        return new AccommodationOption(
            UUID.randomUUID().toString(), "bb", str(m, "name"), ppn, tot,
            num(m, "rating"), str(m, "location"), toStringList(m.get("amenities")),
            str(m, "bookingUrl"), tier, source, str(m, "imageUrl")
        );
    }

    private List<String> toStringList(Object v) {
        if (v instanceof List<?> l) return l.stream().map(Object::toString).collect(Collectors.toList());
        return List.of(); }

    private String resolveProvider(String model) {
        if (model == null) return "anthropic";
        if (model.startsWith("anthropic/")) return "anthropic";
        if (model.startsWith("lmstudio/")) return "lmstudio";
        if (model.startsWith("ollama/")) return "ollama";
        if (model.startsWith("openrouter/")) return "openrouter";
        return "unknown";
    }

public class CarBusAgent {

    private static final Logger log = LoggerFactory.getLogger(CarBusAgent.class);

    private final BrowserAgentService browserService;
    private final LlmService llmService;
    private final ObjectMapper objectMapper;
    private final PromptTemplateService promptTemplateService;
    private final DynamicPromptService dynamicPromptService;
    private final LlmCostTrackingService costTracker;
    private final SearchTargetService searchTargetService;

    @Value("${travel-agency.prompts.car-agent}")
    private String defaultPrompt;

    @Value("${travel-agency.browser.car-sites:rentalcars.com,kayak.com/cars}")
    private String carSites;

    @Value("${travel-agency.browser.bus-sites:flixbus.com,busbud.com,rome2rio.com}")
    private String busSites;

    public CarBusAgent(BrowserAgentService browserService, LlmService llmService,
                       ObjectMapper objectMapper, PromptTemplateService promptTemplateService,
                       Dyn

    public CarBusAgent(BrowserAgentService browserService, LlmService llmService,
                       ObjectMapper objectMapper, PromptTemplateService promptTemplateService,
                       DynamicPromptService dynamicPromptService, LlmCostTrackingService costTracker,
                       SearchTargetService searchTargetService) {
        this.browserService = browserService;
        this.llmService = llmService;
        this.objectMapper = objectMapper;
        this.promptTemplateService = promptTemplateService;
        this.dynamicPromptService = dynamicPromptService;
        this.costTracker = costTracker;
        this.searchTargetService = searchTargetService;
        // Register YAML default (DB version will override if set by admin)
        dynamicPromptService.registerDefault("car-agent", "");
    }

    void init() {
        dynamicPromptService.registerDefault("car-agent", defaultPrompt);
    }

    public List<TransportOption> searchGroundTransport(TravelRequest request) {
        long days = ChronoUnit.DAYS.between(request.startDate(), request.endDate());
        if (days <= 0) days = 1;
        String model = request.extractorModel();

        // Combine car and bus sites for browser search
        String combinedSites = carSites + "," + busSites;

        // -- primary: real browser search --
        if (browserService.isAvailable()) {
            try {
                List<Map<String, Object>> raw = browserService.browseForList(
                    buildBrowserTask(request, days),
                    searchTargetService.getSites("car-agent", combinedSites),
                    "a JSON array of ground transport objects each with: type ('car' or 'bus'), " +
                    "provider (string), departureTime (HH:mm), arrivalTime (HH:mm), " +
                    "duration (string), price (total trip, number), bookingUrl (string), " +
                    "origin (string), d

    private String buildBrowserTask(TravelRequest request, long days) {
        return String.format(
            "Search for 3-4 ground transport options (car rental and/or bus) " +
            "to/from %s for %d people, %s to %s (%d days). Budget: approx. %.0f EUR max total. " +
            "For each option get: type (car or bus), provider, departure time, arrival time, " +
            "duration, total price, booking URL.",
            request.destination(), request.guestCount(),
            request.startDate(), request.endDate(), days, request.budgetMax()
        );
    }

    private TransportOption map(Map<String, Object> m, String source, TravelRequest request) {
        double price = num(m, "price");
        String tier = price < 100 ? "budget" : price > 400 ? "luxury" : "standard";
        String type = str(m, "type");
        if (!type.equals("car") && !type.equals("bus")) type = "car";
        return new TransportOption(
            UUID.randomUUID().toString(), type,
            str(m, "provider"), str(m, "departureTime"), str(m, "arrivalTime"),
            str(m, "duration"), price, 0,
            str(m, "bookingUrl"), tier, source,
            str(m, "origin").isEmpty() ? request.originCity() : str(m, "origin"),
            str(m, "destination").isEmpty() ? request.destination() : str(m, "destination")
        );
    }

    private double num(Map<String, Object> m, String key) {
        Object v = m.get(key); return v instanceof Number n ? n.doubleValue() : 0.0;
    }

    private String str(Map<String, Object> m, String key) {
        Object v = m.get(key); return v != null ? v.toString() : "";
    }

    private String resolveProvider(String model) {
        if (model == null) return "anthropic";
        if (model.startsWith("anthropic/")) return "anthropic";
        if (model.startsWith("lmstudio/")) return "lmstudio";
        if (model.startsWith("ollama/")) return "ollama";
        if (model.startsWith("openrouter/")) return "openrouter";
        return "unknown";
    }

public class CountrySpecialistAgent {

    private static final Logger log = LoggerFactory.getLogger(CountrySpecialistAgent.class);

    private final BrowserAgentService browserService;
    private final LlmService llmService;
    private final ObjectMapper objectMapper;
    private final PromptTemplateService promptTemplateService;
    private final DynamicPromptService dynamicPromptService;
    private final LlmCostTrackingService costTracker;
    private final SearchTargetService searchTargetService;

    @Value("${travel-agency.prompts.country-specialist}")
    private String defaultPrompt;

    @Value("${travel-agency.models.country-specialist:lmstudio/llama-3-8b}")
    private String defaultModel;

    @Value("${travel-agency.browser.country-sites:lonelyplanet.com,wikivoyage.org,tripadvisor.com}")
    private String countrySites;

    public CountrySpecialistAgent(BrowserAgentService browserService, LlmService llmService,
                                  ObjectMapper objectMapp