Function bodies 269 total

    private List<ItineraryVariant> parseVariants(Map<String, Object> synthesized, TravelRequest request) {
        Object variantsRaw = synthesized.get("variants");
        if (!(variantsRaw instanceof List<?> list)) return List.of();

        List<ItineraryVariant> result = new ArrayList<>();
        for (Object item : list) {
            if (!(item instanceof Map<?, ?> v)) continue;
            Map<String, Object> vm = (Map<String, Object>) v;

            List<ItineraryDay> days = parseDays(vm.get("dayByDay"), request);
            result.add(new ItineraryVariant(
                str(vm, "tier"),
                num(vm, "totalEstimatedCost"),
                List.of(), // accommodation objects filled by TravelService later
                List.of(),
                List.of(),
                days,
                toStringList(vm.get("highlights")),
                str(vm, "tradeoffs")
            ));
        }
        return result;
    }

    private List<ItineraryDay> parseDays(Object dayByDayRaw, TravelRequest request) {
        if (!(dayByDayRaw instanceof List<?> dayList)) return generateDefaultDays(request);
        List<ItineraryDay> days = new ArrayList<>();
        for (Object d : dayList) {
            if (!(d instanceof Map<?, ?> dm)) continue;
            Map<String, Object> day = (Map<String, Object>) d;
            days.add(new ItineraryDay(
                ((Number) day.getOrDefault("dayNumber", days.size() + 1)).intValue(),
                str(day, "date"),
                str(day, "title"),
                str(day, "summary"),
                toStringList(day.get("morningActivities")),
                toStringList(day.get("afternoonActivities")),
                toStringList(day.get("eveningActivities")),
                toStringList(day.get("meals")),
                str(day, "transportNotes"),
                num(day, "estimatedDayCost")
            ));
        }
        return days;
    }

    List<ItineraryDay> generateDefaultDays(TravelRequest request) {
        List<ItineraryDay> days = new ArrayList<>();
        long nights = request.nights();
        for (int i = 1; i <= nights; i++) {
            LocalDate date = request.startDate().plusDays(i - 1);
            String title = i == 1 ? "Arrival Day" : i == nights ? "Departure Day" : "Day " + i;
            days.add(new ItineraryDay(i, date.toString(), title,
                "Explore " + request.destination(),
                List.of("Morning activity"), List.of("Afternoon activity"),
                List.of("Evening activity"), List.of("Local restaurant"),
                "", 0));
        }
        return days;
    }

    List<ItineraryVariant> buildFallbackVariants(
            List<AccommodationOption> accommodations, List<TransportOption> transport,
            List<AttractionOption> attractions, TravelRequest request) {
        // Group by tier and build basic variants
        List<ItineraryVariant> variants = new ArrayList<>();
        for (String tier : List.of("budget", "standard", "luxury")) {
            List<AccommodationOption> tierAccom = accommodations.stream()
                .filter(a -> tier.equals(a.tier())).toList();
            List<TransportOption> tierTransport = transport.stream()
                .filter(t -> tier.equals(t.tier())).toList();
            List<AttractionOption> tierAttract = attractions != null ? attractions.stream()
                .filter(a -> tier.equals(a.tier())).toList() : List.of();

            double cost = tierAccom.stream().mapToDouble(AccommodationOption::totalPrice).sum()
                        + tierTransport.stream().mapToDouble(TransportOption::p

    private List<String> toStringList(Object v) {
        if (v instanceof List<?> l) return l.stream().map(Object::toString).collect(java.util.stream.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 ReviewSummaryAgent {

    private static final Logger log = LoggerFactory.getLogger(ReviewSummaryAgent.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;

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

    public ReviewSummaryAgent(BrowserAgentService browserService, LlmService llmService,
                              ObjectMapper objectMapper, PromptTemplateService promptTemplateService,
                              DynamicPromptService dynamicPromptService, LlmCostTrackingService costTracker) {
        this.browserService = browserService;
        this.llmService = llmService;
        this.objectMapper = objectMapper;
        this.promptTemplateServic

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

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

    public Map<String, Object> getReviewSummary(TravelRequest request) {
        String model = request.extractorModel();

        try {
            String systemPrompt = dynamicPromptService.getPrompt("review-summary-agent");
            if (systemPrompt.isBlank()) systemPrompt = defaultPrompt;

            String userPrompt = String.format(
                "Synthesize a traveler review summary for %s, considering the travel period %s to %s " +
                "and travel style '%s'. " +
                "Return a JSON object with keys: " +
                "overallSentiment (string, e.g. 'Very Positive', 'Positive', 'Mixed', 'Negative'), " +
                "topPros (array of strings, 3-5 most praised aspects), " +
                "topCons (array of strings, 3-5 most common complaints), " +
                "bestFor (array of strings, traveler types this destination suits best), " +
                "avoidIf (array of strings, reasons someone might want to skip this destination), " +
   

    private Map<String, Object> defaultReviewSummary(String destination) {
        Map<String, Object> d = new HashMap<>();
        d.put("overallSentiment", "Positive");
        d.put("topPros", List.of(
            "Rich cultural heritage and history",
            "Diverse food scene",
            "Friendly locals"
        ));
        d.put("topCons", List.of(
            "Can be crowded during peak season",
            "Tourist-area prices may be inflated",
            "Language barrier in some areas"
        ));
        d.put("bestFor", List.of(
            "Culture enthusiasts",
            "Food lovers",
            "History buffs"
        ));
        d.put("avoidIf", List.of(
            "You prefer off-the-beaten-path destinations",
            "You are on a very tight budget during peak season"
        ));
        d.put("safetyRating", "Generally Safe");
        d.put("cleanlinessRating", "Good");
        return d;
    }

    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 TrainAgent {

    private static final Logger log = LoggerFactory.getLogger(TrainAgent.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.train-agent}")
    private String defaultPrompt;

    @Value("${travel-agency.browser.train-sites:thetrainline.com,omio.com,seat61.com}")
    private String trainSites;

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

    public TrainAgent(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("train-agent", "");
    }

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

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

        // -- primary: real browser search --
        if (browserService.isAvailable()) {
            try {
                List<Map<String, Object>> raw = browserService.browseForList(
                    buildBrowserTask(request, days),
                    searchTargetService.getSites("train-agent", trainSites),
                    "a JSON array of train route objects each with: operator (string), " +
                    "departureTime (HH:mm), arrivalTime (HH:mm), duration (string), " +
                    "stops (integer), price (per person, number), bookingUrl (string), " +
                    "class (string), origin (string), destination (string)",
                    model
                );
                if (raw != null && !raw.isEmpty()) {

    private String buildBrowserTask(TravelRequest request, long days) {
        return String.format(
            "Search for 4-6 train routes for %d passengers from %s to %s, " +
            "departing %s. Trip duration: %d days. Max budget per person: approx. %.0f EUR. " +
            "Include both standard and first-class options. " +
            "For each train get: operator, departure time, arrival time, duration, stops, " +
            "price per person, booking URL, class.",
            request.guestCount(),
            request.originCity().isEmpty() ? "nearest major station" : request.originCity(),
            request.destination(),
            request.startDate(), days, request.budgetMax()
        );
    }

    private TransportOption map(Map<String, Object> m, String source, TravelRequest request) {
        double price = num(m, "price");
        String tier = price < 80 ? "budget" : price > 300 ? "luxury" : "standard";
        return new TransportOption(
            UUID.randomUUID().toString(), "train",
            str(m, "operator"), str(m, "departureTime"), str(m, "arrivalTime"),
            str(m, "duration"), price,
            ((Number) m.getOrDefault("stops", 0)).intValue(),
            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 TravelPlannerAgent {

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

    private final HotelAgent hotelAgent;
    private final BBAgent bbAgent;
    private final ApartmentAgent apartmentAgent;
    private final HostelAgent hostelAgent;
    private final FlightAgent flightAgent;
    private final CarBusAgent carBusAgent;
    private final TrainAgent trainAgent;
    private final FerryAgent ferryAgent;
    private final CountrySpecialistAgent countrySpecialistAgent;
    private final AttractionsAgent attractionsAgent;
    private final WeatherAgent weatherAgent;
    private final CurrencyAgent currencyAgent;
    private final ReviewSummaryAgent reviewSummaryAgent;
    private final OrchestratorAgent orchestratorAgent;
    private final AgentProgressService progressService;
    private final ExecutorService agentExecutor;

    public TravelPlannerAgent(
            HotelAgent hotelAgent, BBAgent bbAgent,
            ApartmentAgent a

    public record TravelIntelligence(
        Map<String, Object> regionInsights,
        Map<String, Object> weatherForecast,
        Map<String, Object> currencyInfo,
        Map<String, Object> reviewSummary
    ) {}

    public record TravelIntelligence(
        Map<String, Object> regionInsights,
        Map<String, Object> weatherForecast,
        Map<String, Object> currencyInfo,
        Map<String, Object> reviewSummary
    ) {}

    public TravelIntelligence gatherIntelligence(TravelRequest request) {
        String sid = request.sessionId();

        CompletableFuture<Map<String, Object>> insightsFuture = CompletableFuture.supplyAsync(() -> {
            emit(sid, "Country Specialist", "searching", 15, "Researching destination...");
            Map<String, Object> r = countrySpecialistAgent.gatherRegionalInsights(
                request.destination(), request.orchestratorModel());
            emit(sid, "Country Specialist", "completed", 100, "Insights ready");
            return r;
        }, agentExecutor);
        CompletableFuture<Map<String, Object>> weatherFuture = CompletableFuture.supplyAsync(() -> {
            emit(sid, "Weather Agent", "searching", 15, "Checking weather...");
            Map<String, Object> r = weatherAgent.getWeatherForecast(request);
            emit(sid, "Weather Agent", "completed", 100, "Weather ready");
            return r;
        }, agentExecutor);
        CompletableFutur

    public AccommodationResults searchAccommodations(TravelRequest request) {
        String sid = request.sessionId();
        List<CompletableFuture<List<AccommodationOption>>> futures = new ArrayList<>();

        if (request.accommodationTypes().contains("hotel")) {
            futures.add(CompletableFuture.supplyAsync(() -> {
                emit(sid, "Hotel Agent", "searching", 20, "Searching hotels...");
                List<AccommodationOption> r = hotelAgent.searchHotels(request);
                emit(sid, "Hotel Agent", "completed", 100, r.size() + " hotels found");
                return r;
            }, agentExecutor));
        }
        if (request.accommodationTypes().contains("bb")) {
            futures.add(CompletableFuture.supplyAsync(() -> {
                emit(sid, "B&B Agent", "searching", 20, "Searching B&Bs...");
                List<AccommodationOption> r = bbAgent.searchBBs(request);
                emit(sid, "B&B Agent", "completed", 100, r.size() + " B&Bs f

    static List<AccommodationOption> dedupeAccommodations(List<AccommodationOption> list) {
        if (list == null || list.isEmpty()) return List.of();
        Map<String, AccommodationOption> best = new LinkedHashMap<>();
        for (AccommodationOption a : list) {
            if (a == null || a.name() == null) continue;
            String key = (a.name().trim().toLowerCase(Locale.ROOT)
                + "|" + (a.location() == null ? "" : a.location().trim().toLowerCase(Locale.ROOT)));
            AccommodationOption prior = best.get(key);
            if (prior == null || isBetter(a, prior)) {
                best.put(key, a);
            }
        }
        return new ArrayList<>(best.values());
    }

    private static boolean isBetter(AccommodationOption candidate, AccommodationOption incumbent) {
        if (candidate.pricePerNight() < incumbent.pricePerNight()) return true;
        if (candidate.pricePerNight() == incumbent.pricePerNight()) {
            return "browser".equalsIgnoreCase(candidate.source())
                && !"browser".equalsIgnoreCase(incumbent.source());
        }
        return false;
    }

    public TransportResults searchTransport(TravelRequest request) {
        String sid = request.sessionId();
        List<CompletableFuture<List<TransportOption>>> futures = new ArrayList<>();

        if (request.transportTypes().contains("flight")) {
            futures.add(CompletableFuture.supplyAsync(() -> {
                emit(sid, "Flight Agent", "searching", 20, "Searching flights...");
                List<TransportOption> r = flightAgent.searchFlights(request);
                emit(sid, "Flight Agent", "completed", 100, r.size() + " flights found");
                return r;
            }, agentExecutor));
        }
        if (request.transportTypes().contains("car") || request.transportTypes().contains("bus")) {
            futures.add(CompletableFuture.supplyAsync(() -> {
                emit(sid, "Car/Bus Agent", "searching", 20, "Searching ground transport...");
                List<TransportOption> r = carBusAgent.searchGroundTransport(request);
                emit(

    static List<TransportOption> dedupeTransport(List<TransportOption> list) {
        if (list == null || list.isEmpty()) return List.of();
        Map<String, TransportOption> best = new LinkedHashMap<>();
        for (TransportOption t : list) {
            if (t == null) continue;
            String key = String.join("|",
                String.valueOf(t.type()).toLowerCase(Locale.ROOT),
                String.valueOf(t.provider()).toLowerCase(Locale.ROOT),
                String.valueOf(t.origin()).toLowerCase(Locale.ROOT),
                String.valueOf(t.destination()).toLowerCase(Locale.ROOT));
            TransportOption prior = best.get(key);
            if (prior == null || isBetterTransport(t, prior)) {
                best.put(key, t);
            }
        }
        return new ArrayList<>(best.values());
    }

    private static boolean isBetterTransport(TransportOption candidate, TransportOption incumbent) {
        if (candidate.price() < incumbent.price()) return true;
        if (candidate.price() == incumbent.price()) {
            return "browser".equalsIgnoreCase(candidate.source())
                && !"browser".equalsIgnoreCase(incumbent.source());
        }
        return false;
    }

    public AttractionResults searchAttractions(TravelRequest request) {
        String sid = request.sessionId();
        emit(sid, "Attractions Agent", "searching", 20, "Finding attractions...");
        List<AttractionOption> results = attractionsAgent.searchAttractions(request);
        emit(sid, "Attractions Agent", "completed", 100, results.size() + " attractions found");
        return new AttractionResults(results);
    }

    public UnforgettableItinerary synthesize(
            TravelRequest request,
            TravelIntelligence intelligence,
            AccommodationResults accommodations,
            TransportResults transport,
            AttractionResults attractions) {

        String sid = request.sessionId();
        emit(sid, "Orchestrator", "analyzing", 90, "Synthesising itinerary...");

        // Merge review data into insights
        Map<String, Object> insights = new HashMap<>(intelligence.regionInsights());
        if (intelligence.reviewSummary() != null && !intelligence.reviewSummary().isEmpty()) {
            insights.put("reviewSummary", intelligence.reviewSummary());
        }

        UnforgettableItinerary itinerary = orchestratorAgent.synthesizeItinerary(
            request,
            accommodations.items(),
            transport.items(),
            attractions.items(),
            insights,
            intelligence.weatherForecast(),
            intelligence.currencyInfo()

    private void emit(String sessionId, String agent, String status, int progress, String message) {
        if (sessionId != null && !sessionId.isBlank()) {
            progressService.update(sessionId, agent, status, progress, message);
        }
    }

public class WeatherAgent {

    private static final Logger log = LoggerFactory.getLogger(WeatherAgent.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;

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

    public WeatherAgent(BrowserAgentService browserService, LlmService llmService,
                        ObjectMapper objectMapper, PromptTemplateService promptTemplateService,
                        DynamicPromptService dynamicPromptService, LlmCostTrackingService costTracker) {
        this.browserService = browserService;
        this.llmService = llmService;
        this.objectMapper = objectMapper;
        this.promptTemplateService = promptTemplateService;
        th

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

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

    public Map<String, Object> getWeatherForecast(TravelRequest request) {
        String model = request.extractorModel();

        try {
            String systemPrompt = dynamicPromptService.getPrompt("weather-agent");
            if (systemPrompt.isBlank()) systemPrompt = defaultPrompt;

            String userPrompt = String.format(
                "Provide a weather forecast for %s during the travel period %s to %s. " +
                "Return a JSON object with keys: averageTemp (number in Celsius), " +
                "highTemp (number in Celsius), lowTemp (number in Celsius), " +
                "precipitation (string description like 'moderate rainfall expected'), " +
                "humidity (string like 'high' or '70%%'), " +
                "packingTips (array of strings with specific clothing/gear recommendations), " +
                "weatherWarnings (array of strings with any seasonal alerts or concerns). " +
                "Return ONLY valid JSON.",
                r

    private Map<String, Object> defaultForecast(String destination) {
        Map<String, Object> d = new HashMap<>();
        d.put("averageTemp", 20);
        d.put("highTemp", 25);
        d.put("lowTemp", 15);
        d.put("precipitation", "Check local forecast closer to travel date");
        d.put("humidity", "Moderate");
        d.put("packingTips", List.of(
            "Pack layers for variable temperatures",
            "Bring a light rain jacket",
            "Comfortable walking shoes recommended"
        ));
        d.put("weatherWarnings", List.of(
            "Weather data is estimated; check an up-to-date forecast before departure"
        ));
        return d;
    }

    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 ExecutorConfig {

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

    @Bean(name = "agentExecutor", destroyMethod = "shutdown")
    public ExecutorService agentExecutor() {
        log.info("Creating virtual-thread executor for agent dispatch (Java 21 Loom)");
        return Executors.newVirtualThreadPerTaskExecutor();
    }
}

    public ExecutorService agentExecutor() {
        log.info("Creating virtual-thread executor for agent dispatch (Java 21 Loom)");
        return Executors.newVirtualThreadPerTaskExecutor();
    }

public class AdminController {

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

    @Value("${matoe.admin.token:}")
    private String adminToken;

    private final DynamicPromptService promptService;
    private final LlmCostTrackingService costService;
    private final SearchTargetRepository searchTargetRepo;
    private final Environment env;

    public AdminController(DynamicPromptService promptService,
                           LlmCostTrackingService costService,
                           SearchTargetRepository searchTargetRepo,
                           Environment env) {
        this.promptService = promptService;
        this.costService = costService;
        this.searchTargetRepo = searchTargetRepo;
        this.env = env;
    }

    @PostConstruct
    void validateAuthPosture() {
        boolean isProduction = Arrays.asList(env.getActiveProfiles()).contains("docker")
                            || Arrays.asList(env.getActiveProfil

    public AdminController(DynamicPromptService promptService,
                           LlmCostTrackingService costService,
                           SearchTargetRepository searchTargetRepo,
                           Environment env) {
        this.promptService = promptService;
        this.costService = costService;
        this.searchTargetRepo = searchTargetRepo;
        this.env = env;
    }

    void validateAuthPosture() {
        boolean isProduction = Arrays.asList(env.getActiveProfiles()).contains("docker")
                            || Arrays.asList(env.getActiveProfiles()).contains("prod");
        boolean tokenUnset = adminToken == null || adminToken.isBlank();
        if (isProduction && tokenUnset) {
            // Fail closed: refuse to start if deployed without an admin token
            throw new IllegalStateException(
                "MATOE_ADMIN_TOKEN is required in production (profile=docker/prod). " +
                "Set the env var before starting the stack. Admin mutation endpoints " +
                "will NOT start without a token to avoid accidental open-access deployments."
            );
        }
        if (tokenUnset) {
            log.warn("MATOE_ADMIN_TOKEN is unset — admin mutation endpoints are OPEN. " +
                     "This is only acceptable for local dev. Set MATOE_ADMIN_TOKEN for any shared deployment.");
        }
    }

    private void requireAuth(String token) {
        if (adminToken != null && !adminToken.isBlank()) {
            if (token == null || !token.equals(adminToken)) {
                throw new org.springframework.web.server.ResponseStatusException(
                    org.springframework.http.HttpStatus.UNAUTHORIZED, "Invalid admin token");
            }
        }
    }

    public ResponseEntity<Map<String, Object>> getAllPrompts() {
        Set<String> agents = promptService.getAgentNames();
        List<Map<String, Object>> prompts = new ArrayList<>();
        for (String agent : agents) {
            prompts.add(Map.of(
                "agentName", agent,
                "activePrompt", promptService.getPrompt(agent),
                "historyCount", promptService.getHistory(agent).size()
            ));
        }
        return ResponseEntity.ok(Map.of("prompts", prompts));
    }

    public ResponseEntity<Map<String, Object>> getPromptDetail(@PathVariable String agentName) {
        return ResponseEntity.ok(Map.of(
            "agentName", agentName,
            "activePrompt", promptService.getPrompt(agentName),
            "history", promptService.getHistory(agentName)
        ));
    }

    public ResponseEntity<Map<String, Object>> getSessionCost(@PathVariable String sessionId) {
        return ResponseEntity.ok(costService.getSessionCostSummary(sessionId));
    }

    public ResponseEntity<List<SearchTargetEntity>> getAllSearchTargets() {
        return ResponseEntity.ok(searchTargetRepo.findAllByOrderByAgentNameAscPriorityAsc());
    }