self-evolve-framework 1.6.0 → 1.6.1

package/template/skills/skillopt-sleep/scripts/framework/skillopt/envs/officeqa/skills/initial.md

@@ -1,15 +0,0 @@
-# OfficeQA Skill
-
-## Retrieval Discipline
-- Start by narrowing to the most likely candidate file before reading long passages.
-- Prefer targeted search terms that name the exact entity, period, measure, or table concept from the question.
-- After a promising match, read only a small surrounding span and verify it matches the requested year, basis, and unit.
-
-## Evidence Discipline
-- Extract the exact value from the retrieved text before doing any arithmetic.
-- Keep track of each operand's period, unit, and semantic role so nearby proxy values are not mixed in.
-- If the question asks for a transformed or derived quantity, compute only after confirming every operand.
-
-## Final Answer Discipline
-- Return the final answer only after one last consistency check against the retrieved evidence.
-- Copy the final answer from a checked value, not from an unverified intermediate guess.

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

@@ -1,552 +0,0 @@
-from __future__ import annotations
-
-import fnmatch
-import html
-import json
-import os
-import re
-import socket
-import time
-from functools import lru_cache
-from html.parser import HTMLParser
-from pathlib import Path
-from urllib.error import HTTPError, URLError
-from urllib.parse import parse_qs, urlparse
-from urllib.request import Request, urlopen
-
-_MAX_READ_CHARS = 4000
-_MAX_GREP_MATCHES = 20
-_MAX_GLOB_MATCHES = 50
-_MAX_ORACLE_PAGE_CHARS = 24000
-_MAX_ORACLE_CONTEXT_CHARS = 80000
-DEFAULT_USER_AGENT = (
-    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
-    "(KHTML, like Gecko) Chrome/135.0 Safari/537.36"
-)
-DEFAULT_CUSTOM_SEARCH_URL = "http://apisix.westus2.cloudapp.azure.com/search_tool/search"
-DEFAULT_CUSTOM_SEARCH_AUTH_ENV = "OFFICEQA_CUSTOM_SEARCH_AUTH"
-DEFAULT_CUSTOM_SEARCH_PROVIDER = "duckduckgo"
-DEFAULT_CUSTOM_SEARCH_MAX_RESULTS = 4
-DEFAULT_CUSTOM_SEARCH_TIMEOUT = 20
-DEFAULT_CUSTOM_SEARCH_MAX_RETRIES = 4
-DEFAULT_CUSTOM_SEARCH_INITIAL_BACKOFF_SECONDS = 1.0
-
-
-def _normalize_data_dirs(data_dirs: list[str] | tuple[str, ...] | str | None, project_root: Path) -> list[str]:
-    if data_dirs is None:
-        return []
-    if isinstance(data_dirs, str):
-        items = [part.strip() for chunk in data_dirs.split(os.pathsep) for part in chunk.split(",")]
-    else:
-        items = [str(item).strip() for item in data_dirs]
-    resolved: list[str] = []
-    for item in items:
-        if not item:
-            continue
-        path = Path(item).expanduser()
-        if not path.is_absolute():
-            path = project_root / path
-        resolved.append(str(path))
-    return resolved
-
-
-def resolve_docs_roots(data_dirs: list[str] | tuple[str, ...] | str | None = None) -> list[str]:
-    project_root = Path(__file__).resolve().parents[3]
-    env_value = os.environ.get("OFFICEQA_DOCS_DIR", "").strip()
-    candidates = _normalize_data_dirs(data_dirs, project_root)
-    candidates.extend(_normalize_data_dirs(env_value, project_root))
-    candidates.extend([
-        str(project_root / "data" / "officeqa_docs_official"),
-        str(project_root / "data" / "officeqa_smoke_docs"),
-        os.path.expanduser("~/officeqa-sparse/treasury_bulletins_parsed"),
-        os.path.expanduser("~/officeqa/treasury_bulletins_parsed"),
-    ])
-    roots: list[str] = []
-    seen: set[str] = set()
-    for candidate in candidates:
-        path = Path(candidate).expanduser()
-        if not path.is_dir():
-            continue
-        transformed = path / "transformed"
-        resolved = str((transformed if transformed.is_dir() else path).resolve())
-        if resolved in seen:
-            continue
-        seen.add(resolved)
-        roots.append(resolved)
-    if not roots:
-        raise FileNotFoundError("OfficeQA docs directory not found. Set OFFICEQA_DOCS_DIR or env.data_dirs.")
-    return roots
-
-
-def _is_allowed(path: str, allowed_roots: list[str], allowed_files: list[str]) -> bool:
-    try:
-        resolved = str(Path(path).resolve())
-    except FileNotFoundError:
-        return False
-    if not any(resolved.startswith(root + os.sep) or resolved == root for root in allowed_roots):
-        return False
-    if not allowed_files:
-        return True
-    base = os.path.basename(resolved)
-    return base in allowed_files
-
-
-def resolve_candidate_files(source_files: list[str], allowed_roots: list[str]) -> list[str]:
-    resolved: list[str] = []
-    seen: set[str] = set()
-    for root in allowed_roots:
-        for dirpath, _, filenames in os.walk(root):
-            for filename in filenames:
-                if source_files and filename not in source_files:
-                    continue
-                full = str(Path(dirpath, filename).resolve())
-                if full in seen:
-                    continue
-                seen.add(full)
-                resolved.append(full)
-    return resolved
-
-
-def _as_list(value: object) -> list[str]:
-    if value is None:
-        return []
-    if isinstance(value, list):
-        return [str(item).strip() for item in value if str(item).strip()]
-    text = str(value).strip()
-    if not text:
-        return []
-    try:
-        loaded = json.loads(text)
-    except json.JSONDecodeError:
-        loaded = None
-    if isinstance(loaded, list):
-        return [str(item).strip() for item in loaded if str(item).strip()]
-    if "\n" in text:
-        return [part.strip() for part in text.splitlines() if part.strip()]
-    return [text]
-
-
-def _extract_page_number(source_doc: str) -> int | None:
-    text = str(source_doc or "").strip()
-    if not text:
-        return None
-    parsed = urlparse(text)
-    query = parse_qs(parsed.query)
-    for key in ("page", "pagenum", "page_id"):
-        for raw_value in query.get(key, []):
-            try:
-                return int(str(raw_value).strip())
-            except ValueError:
-                continue
-    match = re.search(r"(?:[?&]|^)page=(\d+)", text)
-    if match:
-        return int(match.group(1))
-    return None
-
-
-def _iter_oracle_refs(source_files: object, source_docs: object) -> list[tuple[str, int, str]]:
-    files = _as_list(source_files)
-    docs = _as_list(source_docs)
-    refs: list[tuple[str, int, str]] = []
-    seen: set[tuple[str, int, str]] = set()
-    if not files or not docs:
-        return refs
-    for index, source_doc in enumerate(docs):
-        page_number = _extract_page_number(source_doc)
-        if page_number is None:
-            continue
-        if index < len(files):
-            source_file = files[index]
-        elif len(files) == 1:
-            source_file = files[0]
-        else:
-            continue
-        key = (source_file, page_number, source_doc)
-        if key in seen:
-            continue
-        seen.add(key)
-        refs.append(key)
-    return refs
-
-
-def _parsed_root_candidates(docs_roots: list[str]) -> list[Path]:
-    candidates: list[Path] = []
-    seen: set[str] = set()
-    for root in docs_roots:
-        path = Path(root).expanduser()
-        for candidate in (
-            path,
-            path.parent,
-            path / "treasury_bulletins_parsed",
-            path.parent / "treasury_bulletins_parsed",
-        ):
-            resolved = str(candidate.resolve()) if candidate.exists() else str(candidate)
-            if resolved in seen:
-                continue
-            seen.add(resolved)
-            candidates.append(candidate)
-    return candidates
-
-
-def _locate_parsed_json(source_file: str, docs_roots: list[str]) -> Path | None:
-    source_path = Path(str(source_file).strip())
-    stem = source_path.stem if source_path.suffix else source_path.name
-    if not stem:
-        return None
-    candidate_names = [stem + ".json"]
-    if source_path.suffix == ".json":
-        candidate_names.insert(0, source_path.name)
-    for root in _parsed_root_candidates(docs_roots):
-        for name in candidate_names:
-            path = root / "jsons" / name
-            if path.is_file():
-                return path
-    return None
-
-
-class _TableMarkdownParser(HTMLParser):
-    def __init__(self) -> None:
-        super().__init__(convert_charrefs=True)
-        self.rows: list[list[str]] = []
-        self._row: list[str] | None = None
-        self._cell: list[str] | None = None
-
-    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
-        if tag.lower() == "tr":
-            self._row = []
-        elif tag.lower() in {"td", "th"} and self._row is not None:
-            self._cell = []
-
-    def handle_data(self, data: str) -> None:
-        if self._cell is not None:
-            self._cell.append(data)
-
-    def handle_endtag(self, tag: str) -> None:
-        normalized_tag = tag.lower()
-        if normalized_tag in {"td", "th"} and self._cell is not None and self._row is not None:
-            cell = re.sub(r"\s+", " ", "".join(self._cell)).strip()
-            self._row.append(cell)
-            self._cell = None
-        elif normalized_tag == "tr" and self._row is not None:
-            if any(cell for cell in self._row):
-                self.rows.append(self._row)
-            self._row = None
-            self._cell = None
-
-
-def _escape_markdown_cell(value: str) -> str:
-    return str(value).replace("\n", " ").replace("|", "\\|").strip()
-
-
-def _html_table_to_markdown(raw_html: str) -> str:
-    parser = _TableMarkdownParser()
-    try:
-        parser.feed(raw_html)
-    except Exception:  # noqa: BLE001
-        parser.rows = []
-    rows = parser.rows
-    if not rows:
-        text = re.sub(r"(?is)<[^>]+>", " ", raw_html)
-        return re.sub(r"\s+", " ", html.unescape(text)).strip()
-    width = max(len(row) for row in rows)
-    normalized_rows = [row + [""] * (width - len(row)) for row in rows]
-    header = normalized_rows[0]
-    body = normalized_rows[1:]
-    lines = [
-        "| " + " | ".join(_escape_markdown_cell(cell) for cell in header) + " |",
-        "| " + " | ".join(["---"] * width) + " |",
-    ]
-    lines.extend("| " + " | ".join(_escape_markdown_cell(cell) for cell in row) + " |" for row in body)
-    return "\n".join(lines)
-
-
-def _render_parsed_content(content: str) -> str:
-    text = content.strip()
-    if not text:
-        return ""
-    if "<table" in text.lower():
-        return _html_table_to_markdown(text)
-    text = html.unescape(text)
-    text = re.sub(r"\r\n?", "\n", text)
-    return re.sub(r"\n{3,}", "\n\n", text).strip()
-
-
-def _element_page_ids(element: dict) -> set[int]:
-    page_ids: set[int] = set()
-    bbox = element.get("bbox")
-    if not isinstance(bbox, list):
-        return page_ids
-    for box in bbox:
-        if not isinstance(box, dict):
-            continue
-        raw_page_id = box.get("page_id")
-        try:
-            page_ids.add(int(raw_page_id))
-        except (TypeError, ValueError):
-            continue
-    return page_ids
-
-
-@lru_cache(maxsize=256)
-def _load_parsed_elements(json_path: str) -> tuple[dict, ...]:
-    with open(json_path, encoding="utf-8") as f:
-        payload = json.load(f)
-    document = payload.get("document") if isinstance(payload, dict) else {}
-    elements = document.get("elements") if isinstance(document, dict) else []
-    if not isinstance(elements, list):
-        return ()
-    return tuple(element for element in elements if isinstance(element, dict))
-
-
-@lru_cache(maxsize=2048)
-def _render_parsed_page(json_path: str, page_number: int) -> str:
-    rendered: list[str] = []
-    for element in _load_parsed_elements(json_path):
-        if page_number not in _element_page_ids(element):
-            continue
-        content = element.get("content")
-        if not isinstance(content, str) or not content.strip():
-            continue
-        section = _render_parsed_content(content)
-        if section:
-            rendered.append(section)
-    return "\n\n".join(rendered).strip()
-
-
-def build_oracle_parsed_pages_context(
-    source_files: object,
-    source_docs: object,
-    docs_roots: list[str],
-    *,
-    max_page_chars: int = _MAX_ORACLE_PAGE_CHARS,
-    max_total_chars: int = _MAX_ORACLE_CONTEXT_CHARS,
-    evidence_note: str = "Treat it as primary document evidence and combine it with custom web search results when useful.",
-) -> str:
-    """Render oracle parsed OfficeQA pages referenced by source_docs/source_files."""
-    refs = _iter_oracle_refs(source_files, source_docs)
-    if not refs:
-        return ""
-
-    blocks: list[str] = []
-    total_chars = 0
-    seen_pages: set[tuple[str, int]] = set()
-    for source_file, page_number, source_doc in refs:
-        json_path = _locate_parsed_json(source_file, docs_roots)
-        if json_path is None:
-            continue
-        page_key = (str(json_path), page_number)
-        if page_key in seen_pages:
-            continue
-        seen_pages.add(page_key)
-        page_text = _render_parsed_page(str(json_path), page_number)
-        if not page_text:
-            continue
-        if len(page_text) > max_page_chars:
-            omitted = len(page_text) - max_page_chars
-            page_text = page_text[:max_page_chars].rstrip() + f"\n\n[... {omitted} characters omitted from this parsed page ...]"
-        block = (
-            f"### {source_file} page {page_number}\n"
-            f"Source URL: {source_doc}\n\n"
-            f"{page_text}"
-        )
-        if total_chars + len(block) > max_total_chars:
-            remaining = max_total_chars - total_chars
-            if remaining <= 0:
-                break
-            block = block[:remaining].rstrip() + "\n\n[... oracle parsed page context truncated ...]"
-            blocks.append(block)
-            break
-        blocks.append(block)
-        total_chars += len(block)
-    if not blocks:
-        return ""
-    return (
-        "The following content is pre-parsed from the oracle OfficeQA source page(s). "
-        f"{evidence_note.strip()}\n\n"
-        + "\n\n".join(blocks)
-    )
-
-
-def _extract_search_items(payload: object) -> list[dict]:
-    if isinstance(payload, list):
-        return [item for item in payload if isinstance(item, dict)]
-    if not isinstance(payload, dict):
-        return []
-    candidate_keys = (
-        "results",
-        "items",
-        "data",
-        "organic",
-        "organic_results",
-        "search_results",
-        "webPages",
-        "value",
-    )
-    for key in candidate_keys:
-        value = payload.get(key)
-        if isinstance(value, list):
-            return [item for item in value if isinstance(item, dict)]
-        if isinstance(value, dict):
-            nested = _extract_search_items(value)
-            if nested:
-                return nested
-    return []
-
-
-def _normalize_search_item(item: dict, index: int) -> str:
-    title = str(
-        item.get("title")
-        or item.get("name")
-        or item.get("headline")
-        or item.get("source")
-        or f"Result {index}"
-    ).strip()
-    url = str(
-        item.get("url")
-        or item.get("link")
-        or item.get("href")
-        or item.get("display_url")
-        or ""
-    ).strip()
-    snippet = str(
-        item.get("snippet")
-        or item.get("description")
-        or item.get("body")
-        or item.get("text")
-        or item.get("content")
-        or ""
-    ).strip()
-    lines = [f"[{index}] {title}"]
-    if url:
-        lines.append(f"URL: {url}")
-    if snippet:
-        lines.append(f"Snippet: {snippet}")
-    return "\n".join(lines)
-
-
-def _format_search_payload(query: str, payload: object) -> str:
-    items = _extract_search_items(payload)
-    header = f"Query: {query}"
-    if not items:
-        body = json.dumps(payload, ensure_ascii=False) if payload else "[no results]"
-        return f"{header}\n{body}"
-    rendered = [_normalize_search_item(item, index) for index, item in enumerate(items, start=1)]
-    return f"{header}\n\n" + "\n\n".join(rendered)
-
-
-def _is_retryable_search_http_error(status_code: int) -> bool:
-    return status_code in {408, 429} or status_code >= 500
-
-
-def custom_search(
-    query: str,
-    *,
-    api_url: str = DEFAULT_CUSTOM_SEARCH_URL,
-    auth_token: str | None = None,
-    auth_env: str = DEFAULT_CUSTOM_SEARCH_AUTH_ENV,
-    provider: str = DEFAULT_CUSTOM_SEARCH_PROVIDER,
-    max_num_results: int = DEFAULT_CUSTOM_SEARCH_MAX_RESULTS,
-    timeout: int = DEFAULT_CUSTOM_SEARCH_TIMEOUT,
-    max_retries: int = DEFAULT_CUSTOM_SEARCH_MAX_RETRIES,
-    initial_backoff_seconds: float = DEFAULT_CUSTOM_SEARCH_INITIAL_BACKOFF_SECONDS,
-) -> str:
-    query = str(query or "").strip()
-    if not query:
-        raise ValueError("custom_search query must be non-empty")
-    token = str(auth_token or os.environ.get(auth_env, "")).strip()
-    if not token:
-        raise ValueError(f"custom_search auth token missing; set {auth_env}")
-    payload = json.dumps(
-        {
-            "query": query,
-            "max_num_results": int(max_num_results),
-            "provider": provider,
-        },
-        ensure_ascii=False,
-    ).encode("utf-8")
-    req = Request(
-        api_url,
-        data=payload,
-        headers={
-            "Authorization": token,
-            "Content-Type": "application/json",
-            "User-Agent": DEFAULT_USER_AGENT,
-        },
-        method="POST",
-    )
-    attempts = max(1, int(max_retries) + 1)
-    last_error: RuntimeError | None = None
-    for attempt in range(1, attempts + 1):
-        try:
-            with urlopen(req, timeout=timeout) as response:
-                raw_body = response.read().decode("utf-8", errors="ignore")
-            break
-        except HTTPError as exc:
-            detail = exc.read().decode("utf-8", errors="ignore")
-            last_error = RuntimeError(f"custom_search HTTP {exc.code}: {detail[:1000]}")
-            if attempt >= attempts or not _is_retryable_search_http_error(exc.code):
-                raise last_error from exc
-        except (URLError, TimeoutError, socket.timeout) as exc:
-            last_error = RuntimeError(f"custom_search connection error: {exc}")
-            if attempt >= attempts:
-                raise last_error from exc
-        backoff_seconds = max(0.0, float(initial_backoff_seconds)) * (2 ** (attempt - 1))
-        if backoff_seconds > 0:
-            time.sleep(backoff_seconds)
-    else:
-        raise last_error or RuntimeError("custom_search failed without a captured error")
-    try:
-        parsed = json.loads(raw_body)
-    except json.JSONDecodeError:
-        return f"Query: {query}\n\n{raw_body.strip() or '[empty response]'}"
-    return _format_search_payload(query, parsed)
-
-
-def run_tool(name: str, arguments: dict, *, allowed_roots: list[str], allowed_files: list[str]) -> tuple[str, str]:
-    if name == "glob":
-        pattern = str(arguments.get("pattern") or "*")
-        matches: list[str] = []
-        for root in allowed_roots:
-            for dirpath, _, filenames in os.walk(root):
-                for filename in filenames:
-                    if allowed_files and filename not in allowed_files:
-                        continue
-                    rel = os.path.relpath(os.path.join(dirpath, filename), root)
-                    if fnmatch.fnmatch(rel, pattern) or fnmatch.fnmatch(filename, pattern):
-                        matches.append(os.path.join(dirpath, filename))
-                    if len(matches) >= _MAX_GLOB_MATCHES:
-                        break
-                if len(matches) >= _MAX_GLOB_MATCHES:
-                    break
-        return f"glob(pattern={pattern!r})", "\n".join(matches) if matches else "[no matches]"
-
-    if name == "read":
-        path = str(arguments.get("path") or "")
-        if not path:
-            return "read(path='')", "[read error: missing path]"
-        if not _is_allowed(path, allowed_roots, allowed_files):
-            return f"read(path={path!r})", "[read error: path not allowed]"
-        start = max(int(arguments.get("start") or 1), 1)
-        limit = max(int(arguments.get("limit") or 80), 1)
-        with open(path, encoding="utf-8") as f:
-            lines = f.readlines()
-        excerpt = "".join(lines[start - 1:start - 1 + limit])
-        return f"read(path={path!r}, start={start}, limit={limit})", excerpt[:_MAX_READ_CHARS] or "[empty file]"
-
-    if name == "grep":
-        pattern = str(arguments.get("pattern") or "").lower()
-        path = str(arguments.get("path") or "")
-        if not pattern or not path:
-            return f"grep(pattern={pattern!r}, path={path!r})", "[grep error: missing pattern or path]"
-        if not _is_allowed(path, allowed_roots, allowed_files):
-            return f"grep(pattern={pattern!r}, path={path!r})", "[grep error: path not allowed]"
-        matches: list[str] = []
-        with open(path, encoding="utf-8") as f:
-            for idx, line in enumerate(f, start=1):
-                if pattern in line.lower():
-                    matches.append(f"{idx}: {line.rstrip()}")
-                if len(matches) >= _MAX_GREP_MATCHES:
-                    break
-        return f"grep(pattern={pattern!r}, path={path!r})", "\n".join(matches) if matches else "[no matches]"
-
-    return name, f"[tool error: unknown tool {name}]"

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

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

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

@@ -1,96 +0,0 @@
-"""SearchQA environment adapter for ReflACT."""
-from __future__ import annotations
-
-import json
-
-from skillopt.datasets.base import BatchSpec
-from skillopt.envs.base import EnvAdapter
-from skillopt.envs.searchqa.dataloader import SearchQADataLoader
-from skillopt.envs.searchqa.rollout import run_batch
-from skillopt.model import get_target_backend
-
-
-class SearchQAAdapter(EnvAdapter):
-    """SearchQA environment adapter."""
-
-    def __init__(
-        self,
-        split_dir: str = "",
-        data_path: str = "",
-        split_mode: str = "ratio",
-        split_ratio: str = "2:1:7",
-        split_seed: int = 42,
-        split_output_dir: str = "",
-        max_turns: int = 1,
-        exec_timeout: int = 120,
-        workers: int = 64,
-        analyst_workers: int = 16,
-        failure_only: bool = False,
-        minibatch_size: int = 8,
-        edit_budget: int = 4,
-        seed: int = 42,
-        limit: int = 0,
-        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.dataloader = SearchQADataLoader(
-            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,  # actually list[dict] for SearchQA
-        skill_content: str,
-        out_dir: str,
-        **kwargs,
-    ) -> list[dict]:
-        """Run QA agent on items. Resume-aware."""
-        items: list[dict] = env_manager  # type alias for clarity
-        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,
-            max_completion_tokens=self.max_completion_tokens,
-            diagnostic_mode=kwargs.get("diagnostic_mode", False),
-            diagnostic_instruction=kwargs.get("diagnostic_instruction", ""),
-            diagnostic_trace_context_by_id=kwargs.get("diagnostic_trace_context_by_id"),
-            task_timeout=self.exec_timeout,
-        )
-
-    def get_task_types(self) -> list[str]:
-        return ["qa"]