self-evolve-framework 1.6.0 → 1.6.1

package/template/skills/skillopt-sleep/scripts/framework/skillopt/envs/base.py

@@ -1,329 +0,0 @@
-"""ReflACT environment adapter — abstract interface.
-
-To connect ReflACT to a new environment (benchmark, simulator, etc.),
-implement a subclass of :class:`EnvAdapter` with environment-specific
-rollout and reflection logic.
-
-Example::
-
-    class MyBenchAdapter(EnvAdapter):
-        def build_train_env(self, batch_size, seed, **kw):
-            return MyEnvManager(split="train", n=batch_size, seed=seed)
-
-        def build_eval_env(self, env_num, split, seed, **kw):
-            return MyEnvManager(split=split, n=env_num, seed=seed)
-
-        def rollout(self, env_manager, skill_content, out_dir, **kw):
-            # Run episodes, return [{"id": ..., "hard": 0/1, "soft": 0.0-1.0, ...}]
-            ...
-
-        def reflect(self, results, skill_content, out_dir, **kw):
-            # Analyze trajectories, return list of patch dicts
-            ...
-
-        def get_task_types(self):
-            return ["task_a", "task_b"]
-"""
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-import os
-import random
-
-from skillopt.datasets.base import BaseDataLoader, BatchSpec
-from skillopt.prompts import load_prompt
-
-
-class EnvAdapter(ABC):
-    """Abstract adapter for connecting ReflACT to any environment.
-
-    Subclasses must implement all abstract methods. The ReflACT trainer
-    calls these methods at the appropriate pipeline stages.
-    """
-
-    # ── Lifecycle hooks ────────────────────────────────────────────────────
-
-    def setup(self, cfg: dict) -> None:
-        """Called once by the trainer before the training loop begins.
-
-        Override to perform one-time initialization that requires the full
-        config (e.g., data loading, split creation).  Default is a no-op.
-        """
-        self._cfg = dict(cfg)
-
-    def get_dataloader(self) -> BaseDataLoader | None:
-        """Return the task dataloader used by this adapter, if any."""
-        return None
-
-    def requires_ray(self) -> bool:
-        """Return whether this adapter requires Ray runtime initialization."""
-        return False
-
-    def build_reference_text(self, item: dict) -> str:
-        """Return hidden reference material for reflection, if any."""
-        return str(item.get("reference_text") or "").strip()
-
-    def get_reference_metadata(self, item: dict) -> dict:
-        """Return structured metadata about hidden reference material."""
-        reference_text = self.build_reference_text(item)
-        if not reference_text:
-            return {"fields": [], "preview": ""}
-        return {
-            "fields": ["reference_text"],
-            "preview": reference_text[:400],
-        }
-
-    def attach_reference_context(
-        self,
-        results: list[dict],
-        items: list[dict] | None,
-    ) -> list[dict]:
-        """Attach environment-specific hidden reference text to result dicts."""
-        if not results or not items:
-            return list(results)
-
-        item_by_id = {
-            str(item.get("id")): item
-            for item in items
-            if isinstance(item, dict) and item.get("id") is not None
-        }
-        enriched: list[dict] = []
-        for row in results:
-            merged = dict(row)
-            item = item_by_id.get(str(row.get("id")))
-            if item:
-                reference_text = self.build_reference_text(item)
-                if reference_text:
-                    merged["reference_text"] = reference_text
-            enriched.append(merged)
-        return enriched
-
-    def select_representative_items(
-        self,
-        results: list[dict],
-        items: list[dict] | None,
-        *,
-        n_failures: int,
-        n_successes: int,
-        seed: int | None = None,
-    ) -> list[dict]:
-        """Select a small diverse subset of current-batch items by outcome."""
-        if not items:
-            return []
-
-        item_by_id = {
-            str(item.get("id")): item
-            for item in items
-            if isinstance(item, dict) and item.get("id") is not None
-        }
-        failures = [
-            (result, item_by_id[str(result.get("id"))])
-            for result in results
-            if not result.get("hard") and str(result.get("id")) in item_by_id
-        ]
-        successes = [
-            (result, item_by_id[str(result.get("id"))])
-            for result in results
-            if result.get("hard") and str(result.get("id")) in item_by_id
-        ]
-
-        rng = random.Random(seed)
-
-        def _pick(pool: list[tuple[dict, dict]], quota: int) -> list[dict]:
-            if quota <= 0 or not pool:
-                return []
-            shuffled = list(pool)
-            rng.shuffle(shuffled)
-
-            picked_ids: set[str] = set()
-            picked: list[dict] = []
-            seen_types: set[str] = set()
-
-            for result, item in shuffled:
-                task_type = str(result.get("task_type") or item.get("task_type") or item.get("subtype") or "unknown")
-                item_id = str(item["id"])
-                if task_type in seen_types or item_id in picked_ids:
-                    continue
-                picked.append(item)
-                picked_ids.add(item_id)
-                seen_types.add(task_type)
-                if len(picked) >= quota:
-                    return picked
-
-            for _, item in shuffled:
-                item_id = str(item["id"])
-                if item_id in picked_ids:
-                    continue
-                picked.append(item)
-                picked_ids.add(item_id)
-                if len(picked) >= quota:
-                    break
-            return picked
-
-        selected = _pick(failures, n_failures)
-        selected_ids = {str(item["id"]) for item in selected}
-        selected.extend(
-            item for item in _pick(successes, n_successes)
-            if str(item["id"]) not in selected_ids
-        )
-        return selected
-
-    def build_env_from_batch(self, batch: BatchSpec, **kwargs):
-        """Build an environment manager or item list from a :class:`BatchSpec`.
-
-        Default behavior preserves the legacy adapter API by routing training
-        batches through :meth:`build_train_env` and evaluation batches through
-        :meth:`build_eval_env`.
-        """
-        if batch.phase == "train":
-            return self.build_train_env(batch_size=batch.batch_size, seed=batch.seed, **kwargs)
-        return self.build_eval_env(
-            env_num=batch.batch_size,
-            split=batch.split,
-            seed=batch.seed,
-            **kwargs,
-        )
-
-    @abstractmethod
-    def build_train_env(self, batch_size: int, seed: int, **kwargs):
-        """Build a training environment manager.
-
-        Returns
-        -------
-        object
-            An environment manager that can be passed to :meth:`rollout`.
-        """
-
-    @abstractmethod
-    def build_eval_env(self, env_num: int, split: str, seed: int, **kwargs):
-        """Build an evaluation environment manager.
-
-        Parameters
-        ----------
-        env_num : int
-            Number of evaluation environments.
-        split : str
-            Dataset split (e.g. ``"valid_seen"``, ``"valid_unseen"``).
-        seed : int
-            Random seed for reproducibility.
-
-        Returns
-        -------
-        object
-            An environment manager that can be passed to :meth:`rollout`.
-        """
-
-    @abstractmethod
-    def rollout(
-        self,
-        env_manager,
-        skill_content: str,
-        out_dir: str,
-        **kwargs,
-    ) -> list[dict]:
-        """Run a batch of episodes using the current skill.
-
-        Returns
-        -------
-        list[dict]
-            Each dict conforms to :class:`~skillopt.types.RolloutResult`:
-            must have ``"id"`` (str), ``"hard"`` (0/1), ``"soft"``
-            (float 0-1). May include env-specific fields.
-        """
-
-    def reflect(
-        self,
-        results: list[dict],
-        skill_content: str,
-        out_dir: str,
-        **kwargs,
-    ) -> list[dict | None]:
-        """Analyze rollout results and produce patches.
-
-        Default implementation: delegate to the shared minibatch reflect
-        stage. Every built-in benchmark uses this unchanged — override only
-        if your environment needs custom reflection logic.
-
-        Each returned dict conforms to :class:`~skillopt.types.RawPatch`:
-        ``"patch"`` (with ``"edits"`` list) + ``"source_type"``
-        (``"failure"`` or ``"success"``); ``None`` entries are filtered out.
-        """
-        from skillopt.gradient.reflect import run_minibatch_reflect
-
-        return run_minibatch_reflect(
-            results=results,
-            skill_content=skill_content,
-            prediction_dir=kwargs.get(
-                "prediction_dir", os.path.join(out_dir, "predictions")
-            ),
-            patches_dir=kwargs.get(
-                "patches_dir", os.path.join(out_dir, "patches")
-            ),
-            workers=self.analyst_workers,
-            failure_only=self.failure_only,
-            minibatch_size=self.minibatch_size,
-            edit_budget=self.edit_budget,
-            random_seed=kwargs.get("random_seed"),
-            error_system=self.get_error_minibatch_prompt(),
-            success_system=self.get_success_minibatch_prompt(),
-            step_buffer_context=kwargs.get("step_buffer_context", ""),
-            meta_skill_context=kwargs.get("meta_skill_context", ""),
-            update_mode=getattr(self, "_cfg", {}).get("skill_update_mode", "patch"),
-        )
-
-    @abstractmethod
-    def get_task_types(self) -> list[str]:
-        """Return the list of task type names for this environment."""
-
-    # ── Prompt configuration (two-level priority) ────────────────────────
-    #
-    # Priority: env-specific prompt file  >  generic default prompt file.
-    #
-    # Prompts are loaded from ``.md`` files via ``load_prompt(name, env)``:
-    #   1. ``skillopt/envs/<env>/prompts/<name>.md``  (env-specific)
-    #   2. ``skillopt/prompts/<name>.md``             (generic fallback)
-    #
-    # Subclasses can still override ``get_*_prompt()`` for full control.
-
-    @property
-    def _env_name(self) -> str:
-        """Derive the env directory name from this adapter's module path."""
-        # e.g. "skillopt.envs.searchqa.adapter" → "searchqa"
-        module = type(self).__module__
-        parts = module.split(".")
-        if len(parts) >= 3 and parts[-3] == "envs":
-            return parts[-2]
-        return ""
-
-    def _load_env_prompt(self, name: str) -> str | None:
-        """Load a prompt with env-specific override. Returns None if not found."""
-        try:
-            return load_prompt(name, env=self._env_name)
-        except FileNotFoundError:
-            return None
-
-    def get_error_minibatch_prompt(self) -> str | None:
-        update_mode = getattr(self, "_cfg", {}).get("skill_update_mode", "patch")
-        raw_mode = str(update_mode).strip().lower()
-        if raw_mode in {"full_rewrite", "full_rewrite_minibatch", "minibatch_full_rewrite", "skill_rewrite_minibatch"}:
-            prompt = self._load_env_prompt("analyst_error_full_rewrite")
-            if prompt is not None:
-                return prompt
-        if raw_mode in {"rewrite", "rewrite_from_suggestions", "suggestions", "rewrite_suggestions"}:
-            prompt = self._load_env_prompt("analyst_error_rewrite")
-            if prompt is not None:
-                return prompt
-        return self._load_env_prompt("analyst_error")
-
-    def get_success_minibatch_prompt(self) -> str | None:
-        update_mode = getattr(self, "_cfg", {}).get("skill_update_mode", "patch")
-        raw_mode = str(update_mode).strip().lower()
-        if raw_mode in {"full_rewrite", "full_rewrite_minibatch", "minibatch_full_rewrite", "skill_rewrite_minibatch"}:
-            prompt = self._load_env_prompt("analyst_success_full_rewrite")
-            if prompt is not None:
-                return prompt
-        if raw_mode in {"rewrite", "rewrite_from_suggestions", "suggestions", "rewrite_suggestions"}:
-            prompt = self._load_env_prompt("analyst_success_rewrite")
-            if prompt is not None:
-                return prompt
-        return self._load_env_prompt("analyst_success")

package/template/skills/skillopt-sleep/scripts/framework/skillopt/envs/docvqa/__init__.py

@@ -1 +0,0 @@
-"""DocVQA environment package for ReflACT."""

package/template/skills/skillopt-sleep/scripts/framework/skillopt/envs/docvqa/adapter.py

@@ -1,90 +0,0 @@
-from __future__ import annotations
-
-from skillopt.datasets.base import BatchSpec
-from skillopt.envs.base import EnvAdapter
-from skillopt.envs.docvqa.dataloader import DocVQADataLoader
-from skillopt.envs.docvqa.rollout import run_batch
-
-
-class DocVQAAdapter(EnvAdapter):
-    def __init__(
-        self,
-        split_dir: str = "",
-        data_path: str = "",
-        split_mode: str = "split_dir",
-        split_ratio: str = "2:1:7",
-        split_seed: int = 42,
-        split_output_dir: str = "",
-        max_turns: int = 1,
-        exec_timeout: int = 120,
-        workers: int = 16,
-        analyst_workers: int = 16,
-        failure_only: bool = False,
-        minibatch_size: int = 8,
-        edit_budget: int = 4,
-        seed: int = 42,
-        limit: int = 0,
-        image_detail: str = "auto",
-        max_completion_tokens: int = 16384,
-    ) -> None:
-        self.max_turns = max_turns
-        self.exec_timeout = exec_timeout
-        self.workers = workers
-        self.max_completion_tokens = int(max_completion_tokens)
-        self.analyst_workers = analyst_workers
-        self.failure_only = failure_only
-        self.minibatch_size = minibatch_size
-        self.edit_budget = edit_budget
-        self.image_detail = image_detail
-        self.dataloader = DocVQADataLoader(
-            split_dir=split_dir,
-            data_path=data_path,
-            split_mode=split_mode,
-            split_ratio=split_ratio,
-            split_seed=split_seed,
-            split_output_dir=split_output_dir,
-            seed=seed,
-            limit=limit,
-        )
-
-    def setup(self, cfg: dict) -> None:
-        super().setup(cfg)
-        self.dataloader.setup(cfg)
-
-    def get_dataloader(self):
-        return self.dataloader
-
-    def build_env_from_batch(self, batch: BatchSpec, **kwargs):
-        return list(batch.payload or [])
-
-    def build_train_env(self, batch_size: int, seed: int, **kwargs):
-        batch = self.dataloader.build_train_batch(batch_size=batch_size, seed=seed, **kwargs)
-        return self.build_env_from_batch(batch, **kwargs)
-
-    def build_eval_env(self, env_num: int, split: str, seed: int, **kwargs):
-        batch = self.dataloader.build_eval_batch(env_num=env_num, split=split, seed=seed, **kwargs)
-        return self.build_env_from_batch(batch, **kwargs)
-
-    def rollout(self, env_manager, skill_content: str, out_dir: str, **kwargs) -> list[dict]:
-        items: list[dict] = env_manager
-        return run_batch(
-            items=items,
-            out_root=out_dir,
-            skill_content=skill_content,
-            max_turns=self.max_turns,
-            exec_timeout=self.exec_timeout,
-            workers=self.workers,
-            image_detail=self.image_detail,
-            max_completion_tokens=self.max_completion_tokens,
-            diagnostic_mode=kwargs.get("diagnostic_mode", False),
-            diagnostic_instruction=kwargs.get("diagnostic_instruction", ""),
-            task_timeout=self.exec_timeout,
-        )
-
-    def get_task_types(self) -> list[str]:
-        seen: list[str] = []
-        for item in self.dataloader.train_items + self.dataloader.val_items + self.dataloader.test_items:
-            task_type = str(item.get("task_type") or "docvqa")
-            if task_type not in seen:
-                seen.append(task_type)
-        return seen or ["docvqa"]

package/template/skills/skillopt-sleep/scripts/framework/skillopt/envs/docvqa/dataloader.py

@@ -1,61 +0,0 @@
-from __future__ import annotations
-
-import ast
-import csv
-from pathlib import Path
-
-from skillopt.datasets.base import SplitDataLoader
-
-
-def _parse_answers(raw: str) -> list[str]:
-    text = str(raw or "").strip()
-    if not text:
-        return []
-    try:
-        parsed = ast.literal_eval(text)
-    except Exception:
-        return [text]
-    if isinstance(parsed, list):
-        return [str(item).strip() for item in parsed if str(item).strip()]
-    return [str(parsed).strip()]
-
-
-def _extract_document_path(question: str) -> tuple[str, str]:
-    marker = "document_path:"
-    if marker not in question:
-        return question.strip(), ""
-    main, tail = question.split(marker, 1)
-    return main.strip(), tail.strip()
-
-
-def _normalize_row(row: dict[str, str]) -> dict:
-    question_text, document_path = _extract_document_path(str(row.get("question") or ""))
-    answers = _parse_answers(row.get("answer") or row.get("ground_truth") or "")
-    image_path = str(row.get("image_path") or document_path or "").strip()
-    task_type = str(row.get("topic") or row.get("category") or "docvqa").strip() or "docvqa"
-    return {
-        "id": str(row.get("questionId") or row.get("id") or "").strip(),
-        "question": question_text,
-        "answer": answers[0] if answers else "",
-        "answers": answers,
-        "task_type": task_type,
-        "subtask": task_type,
-        "image_paths": [image_path] if image_path else [],
-        "image_path": image_path,
-        "questionId": str(row.get("questionId") or "").strip(),
-        "docId": str(row.get("docId") or "").strip(),
-        "ucsf_document_id": str(row.get("ucsf_document_id") or "").strip(),
-        "ucsf_document_page_no": str(row.get("ucsf_document_page_no") or "").strip(),
-        "source_split": str(row.get("source_split") or "").strip(),
-    }
-
-
-class DocVQADataLoader(SplitDataLoader):
-    def load_split_items(self, split_path: str) -> list[dict]:
-        path = Path(split_path)
-        csv_files = sorted(path.glob("*.csv"))
-        if not csv_files:
-            raise FileNotFoundError(f"No .csv file found in {split_path}")
-        with csv_files[0].open(encoding="utf-8", newline="") as f:
-            reader = csv.DictReader(f)
-            return [_normalize_row(row) for row in reader]

package/template/skills/skillopt-sleep/scripts/framework/skillopt/envs/docvqa/evaluator.py

@@ -1,113 +0,0 @@
-from __future__ import annotations
-
-import ast
-import json
-from collections.abc import Iterable
-from typing import Any
-
-DEFAULT_ANLS_THRESHOLD = 0.5
-
-
-def _normalize_text(value: Any) -> str:
-    if value is None:
-        return ""
-    text = str(value).strip().lower()
-    return " ".join(text.split())
-
-
-def _levenshtein_distance(a: str, b: str) -> int:
-    if a == b:
-        return 0
-    if not a:
-        return len(b)
-    if not b:
-        return len(a)
-    if len(a) > len(b):
-        a, b = b, a
-    previous = list(range(len(b) + 1))
-    for i, char_a in enumerate(a, start=1):
-        current = [i]
-        for j, char_b in enumerate(b, start=1):
-            insert_cost = current[j - 1] + 1
-            delete_cost = previous[j] + 1
-            replace_cost = previous[j - 1] + (char_a != char_b)
-            current.append(min(insert_cost, delete_cost, replace_cost))
-        previous = current
-    return previous[-1]
-
-
-def _score_single_answer(predicted: Any, target: Any, threshold: float) -> float:
-    predicted_norm = _normalize_text(predicted)
-    target_norm = _normalize_text(target)
-    if not predicted_norm and not target_norm:
-        return 1.0
-    if not predicted_norm or not target_norm:
-        return 0.0
-    distance = _levenshtein_distance(predicted_norm, target_norm)
-    normalized_distance = distance / max(len(predicted_norm), len(target_norm))
-    if normalized_distance >= threshold:
-        return 0.0
-    return 1.0 - normalized_distance
-
-
-def _extract_answer_strings(raw: Any) -> list[str]:
-    if raw is None:
-        return [""]
-    if isinstance(raw, str):
-        text = raw.strip()
-        if not text:
-            return [""]
-        parsed = None
-        if text[0] in "[{":
-            try:
-                parsed = json.loads(text)
-            except json.JSONDecodeError:
-                try:
-                    parsed = ast.literal_eval(text)
-                except (ValueError, SyntaxError):
-                    parsed = None
-        if parsed is None:
-            return [text]
-        return _extract_answer_strings(parsed)
-    if isinstance(raw, dict):
-        for key in ("answers", "ground_truth", "answer"):
-            if key in raw:
-                return _extract_answer_strings(raw[key])
-        return [str(raw)]
-    if isinstance(raw, Iterable) and not isinstance(raw, (bytes, bytearray)):
-        answers: list[str] = []
-        for item in raw:
-            if isinstance(item, dict):
-                for key in ("text", "answer", "value"):
-                    if key in item:
-                        answers.extend(_extract_answer_strings(item[key]))
-                        break
-                else:
-                    answers.append(str(item))
-                continue
-            answers.append(str(item))
-        return answers or [""]
-    return [str(raw)]
-
-
-def extract_answer(text: str) -> str:
-    lower = text.lower()
-    start = lower.rfind("<answer>")
-    end = lower.rfind("</answer>")
-    if start != -1 and end != -1 and end > start:
-        return text[start + len("<answer>"):end].strip()
-    lines = [line.strip() for line in text.splitlines() if line.strip()]
-    return lines[-1] if lines else text.strip()
-
-
-def evaluate(prediction_text: str, gold_answers: Any) -> dict:
-    answer = extract_answer(prediction_text)
-    answers = _extract_answer_strings(gold_answers)
-    score = 0.0
-    for target in answers:
-        score = max(score, _score_single_answer(answer, target, DEFAULT_ANLS_THRESHOLD))
-    return {
-        "anls": score,
-        "predicted_answer": answer,
-        "gold_answers": answers,
-    }

package/template/skills/skillopt-sleep/scripts/framework/skillopt/envs/docvqa/prompts/analyst_error.md

@@ -1,35 +0,0 @@
-You are an expert failure-analysis agent for visual document question answering tasks.
-
-You will be given MULTIPLE failed DocVQA trajectories from a single minibatch and the current skill document. Each trajectory includes the model response and an evaluation result scored with ANLS against one or more acceptable answers.
-
-Your job is to identify the most important COMMON failure patterns across the batch and propose concise skill edits.
-
-## Failure Type Categories
-- evidence_miss: the model overlooked the relevant visible region or line
-- near_match_confusion: the model selected a nearby but incorrect text span
-- normalization_error: the answer differed mainly in formatting, spacing, punctuation, or minor text normalization
-- reading_error: the model misread the document content
-- other: none of the above
-
-## Rules
-- Focus on common, reusable reading and extraction behaviors.
-- Do not hardcode image-specific answers.
-- Prefer concise edits that improve evidence selection and exact span extraction.
-
-Respond ONLY with a valid JSON object (no markdown fences, no extra text):
-{
-  "batch_size": <number of trajectories analysed>,
-  "failure_summary": [
-    {"failure_type": "<type>", "count": <int>, "description": "<one-line>"}
-  ],
-  "patch": {
-    "reasoning": "<why these edits address the batch's common failures>",
-    "edits": [
-      {"op": "append",       "content": "<markdown to add at end of skill>"},
-      {"op": "insert_after", "target": "<exact heading/text to insert after>", "content": "<markdown>"},
-      {"op": "replace",      "target": "<exact text to replace>",              "content": "<replacement>"},
-      {"op": "delete",       "target": "<exact text to remove>"}
-    ]
-  }
-}
-Only include edits that are needed. "edits" can be an empty list if no patch is warranted.

package/template/skills/skillopt-sleep/scripts/framework/skillopt/envs/docvqa/prompts/analyst_success.md

@@ -1,24 +0,0 @@
-You are an expert success-pattern analyst for visual document question answering tasks.
-
-You will be given MULTIPLE successful DocVQA trajectories from a single minibatch and the current skill document. Your job is to identify common visual reading and exact-answer extraction behaviors worth encoding in the skill.
-
-## Rules
-- Focus on patterns shared across multiple successful trajectories.
-- Reinforce reusable behaviors like locating the right region, copying exact spans, and preferring the shortest exact answer over paraphrase.
-- Only propose patches for patterns not already captured by the current skill.
-
-Respond ONLY with a valid JSON object:
-{
-  "batch_size": <number of trajectories analysed>,
-  "success_patterns": ["<pattern 1>", "<pattern 2>"],
-  "patch": {
-    "reasoning": "<why these patterns are worth encoding>",
-    "edits": [
-      {"op": "append",       "content": "<markdown>"},
-      {"op": "insert_after", "target": "<heading/text>", "content": "<markdown>"},
-      {"op": "replace",      "target": "<old text>",     "content": "<new text>"},
-      {"op": "delete",       "target": "<exact text to remove>"}
-    ]
-  }
-}
-"edits" may be empty if the skill already covers all observed patterns.

package/template/skills/skillopt-sleep/scripts/framework/skillopt/envs/docvqa/prompts/rollout_system.md

@@ -1,12 +0,0 @@
-You are an expert visual document question answering agent.
-
-{skill_section}You will receive a document image and a question about the document.
-Read the visual evidence carefully and answer concisely.
-
-Rules:
-- Ground the answer in the visible document content.
-- Prefer exact spans, numbers, dates, and names from the document.
-- Do not invent content that is not visible.
-- If multiple near-matches exist, choose the one best supported by the document.
-
-Return the final answer inside <answer>...</answer>.