qwen-sci 0.2.2__py3-none-any.whl

src/agents/idea_agent/utils/core/chat_errors.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import json
+from typing import Any, Mapping
+
+
+def _stringify(value: Any) -> str:
+    return str(value or "").strip()
+
+
+def _pick_header(headers: Any, key: str) -> str:
+    if not isinstance(headers, Mapping):
+        return ""
+    return _stringify(headers.get(key) or headers.get(key.title()))
+
+
+def format_chat_retry_error(exc: Exception) -> str:
+    body = getattr(exc, "body", None)
+    error = body.get("error") if isinstance(body, Mapping) else None
+    response = getattr(exc, "response", None)
+    headers = getattr(response, "headers", None)
+
+    status_code = getattr(exc, "status_code", None)
+    error_type = _stringify(
+        (error.get("type") if isinstance(error, Mapping) else None) or getattr(exc, "type", None)
+    )
+    error_code = _stringify(
+        (error.get("code") if isinstance(error, Mapping) else None) or getattr(exc, "code", None)
+    )
+    error_param = _stringify(
+        (error.get("param") if isinstance(error, Mapping) else None) or getattr(exc, "param", None)
+    )
+    request_id = _stringify(
+        getattr(exc, "request_id", None)
+        or (error.get("request_id") if isinstance(error, Mapping) else None)
+        or (body.get("request_id") if isinstance(body, Mapping) else None)
+        or _pick_header(headers, "x-request-id")
+        or _pick_header(headers, "request-id")
+    )
+    message = _stringify(
+        (error.get("message") if isinstance(error, Mapping) else None)
+        or (body.get("message") if isinstance(body, Mapping) else None)
+        or exc
+    )
+
+    parts = [exc.__class__.__name__]
+    if status_code is not None:
+        parts.append(f"status={status_code}")
+    if error_type:
+        parts.append(f"type={error_type}")
+    if error_code:
+        parts.append(f"code={error_code}")
+    if error_param:
+        parts.append(f"param={error_param}")
+    if request_id:
+        parts.append(f"request_id={request_id}")
+    if message:
+        parts.append(f"message={message}")
+    if isinstance(body, Mapping):
+        parts.append(f"body={json.dumps(body, ensure_ascii=True, sort_keys=True)}")
+
+    retry_after = _pick_header(headers, "retry-after")
+    server = _pick_header(headers, "server")
+    if retry_after:
+        parts.append(f"retry_after={retry_after}")
+    if server:
+        parts.append(f"server={server}")
+
+    return "; ".join(parts)
+
+
+def is_non_retryable_chat_error(exc: Exception) -> bool:
+    """Return true for deterministic client/request errors such as oversized input."""
+
+    status = getattr(exc, "status_code", None)
+    try:
+        status_value = int(status) if status is not None else None
+    except (TypeError, ValueError):
+        status_value = None
+    if status_value is not None:
+        if status_value in {408, 409, 425, 429}:
+            return False
+        if 400 <= status_value < 500:
+            return True
+    detail = format_chat_retry_error(exc).casefold()
+    return (
+        "invalid_parameter_error" in detail
+        or "range of input length" in detail
+        or "context length" in detail
+        or "maximum context" in detail
+        or "chat prompt must not be empty" in detail
+    )
+
+
+__all__ = ["format_chat_retry_error", "is_non_retryable_chat_error"]

src/agents/idea_agent/utils/core/chat_router.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Mapping
+
+from src.llm.provider_registry import resolve_model
+
+
+HIGH_REASONING_STAGES = frozenset(
+    {
+        "advanced_analysis",
+        "algorithm_alignment",
+        "algorithm_structuring",
+        "experiment_findings_extraction",
+        "idea_fusion",
+        "mcts_expand",
+        "re_analysis_replan",
+        "scientific_materialization",
+    }
+)
+
+
+def _is_gpt5_family(model: str) -> bool:
+    normalized = str(model or "").strip().lower()
+    return normalized.startswith("gpt-5")
+
+
+def _is_gemini_3_pro_family(model: str) -> bool:
+    normalized = str(model or "").strip().lower()
+    return normalized.startswith(("gemini-3-pro", "gemini-3.1-pro"))
+
+
+def _is_claude_opus_4_6_family(model: str) -> bool:
+    normalized = str(model or "").strip().lower()
+    return normalized.startswith("claude-opus-4-6")
+
+
+def _is_claude_sonnet_4_6_family(model: str) -> bool:
+    normalized = str(model or "").strip().lower()
+    return normalized.startswith("claude-sonnet-4-6")
+
+
+def _is_deepseek_v3_2_family(model: str) -> bool:
+    normalized = str(model or "").strip().lower()
+    return normalized.startswith("deepseek-v3.2")
+
+
+def _is_kimi_k2_5_family(model: str) -> bool:
+    normalized = str(model or "").strip().lower()
+    return normalized.startswith("kimi-k2.5")
+
+
+def _is_glm_5_family(model: str) -> bool:
+    normalized = str(model or "").strip().lower()
+    return normalized.startswith("glm-5")
+
+
+def _qwen_api_style(model: str) -> str | None:
+    normalized = str(model or "").strip().lower()
+    if normalized.startswith("qwen3-max"):
+        return "responses"
+    if normalized.startswith(("qwen3.", "qwen3-")):
+        return "chat_completions"
+    return None
+
+
+def _strip_gpt_only_parameters(request_kwargs: Dict[str, Any]) -> None:
+    for key in ("reasoning", "reasoning_effort", "verbosity", "service_tier"):
+        request_kwargs.pop(key, None)
+
+
+def prepare_ligagent_chat_request(
+    *,
+    model: str,
+    stage: str,
+    kwargs: Mapping[str, Any],
+    config: Any = None,
+) -> tuple[str, Dict[str, Any]]:
+    resolved_model = str(model or "").strip()
+    if not resolved_model:
+        raise ValueError("LigAgent chat requires a non-empty model name.")
+
+    request_kwargs = dict(kwargs)
+
+    qwen_style = _qwen_api_style(resolved_model)
+    if qwen_style is not None:
+        _strip_gpt_only_parameters(request_kwargs)
+        return resolved_model, request_kwargs
+
+    try:
+        model_spec = resolve_model(config, resolved_model)
+    except (ValueError, TypeError):
+        model_spec = None
+    if model_spec is not None:
+        if model_spec.provider == "qwen":
+            if model_spec.api_style not in {"chat_completions", "responses"}:
+                raise ValueError(
+                    f"Unsupported LigAgent chat model protocol: {resolved_model} "
+                    f"({model_spec.api_style})"
+                )
+            _strip_gpt_only_parameters(request_kwargs)
+            return resolved_model, request_kwargs
+        if model_spec.provider != "openai" and model_spec.api_style in {"chat_completions", "responses"}:
+            return resolved_model, request_kwargs
+
+    if _is_gpt5_family(resolved_model):
+        request_kwargs["temperature"] = 1.0
+        request_kwargs["reasoning"] = {
+            "effort": "high" if stage in HIGH_REASONING_STAGES else "low"
+        }
+        return resolved_model, request_kwargs
+
+    if _is_gemini_3_pro_family(resolved_model):
+        return resolved_model, request_kwargs
+
+    if _is_claude_opus_4_6_family(resolved_model):
+        return resolved_model, request_kwargs
+
+    if _is_claude_sonnet_4_6_family(resolved_model):
+        return resolved_model, request_kwargs
+
+    if _is_deepseek_v3_2_family(resolved_model):
+        return resolved_model, request_kwargs
+
+    if _is_kimi_k2_5_family(resolved_model):
+        return resolved_model, request_kwargs
+
+    if _is_glm_5_family(resolved_model):
+        return resolved_model, request_kwargs
+
+    raise ValueError(f"Unsupported LigAgent chat model: {resolved_model}")

src/agents/idea_agent/utils/core/chat_transport.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Mapping, Optional
+from urllib.parse import urlparse
+
+from src.llm.provider_registry import clamp_output_tokens, resolve_model
+
+_SUPPORTED_API_STYLES = {"auto", "responses", "chat_completions"}
+
+
+def normalize_api_style(api_style: Optional[str]) -> str:
+    style = str(api_style or "auto").strip().lower()
+    if style not in _SUPPORTED_API_STYLES:
+        supported = ", ".join(sorted(_SUPPORTED_API_STYLES))
+        raise ValueError(f"Unsupported OPENAI_API_STYLE '{style}'. Expected one of: {supported}.")
+    return style
+
+
+def _model_prefers_chat_completions(model: Optional[str]) -> bool:
+    normalized = str(model or "").strip().lower()
+    return (
+        normalized.startswith(("gemini-3-pro", "gemini-3.1-pro"))
+        or normalized.startswith("claude-opus-4-6")
+        or normalized.startswith("claude-sonnet-4-6")
+        or normalized.startswith("deepseek-v3.2")
+        or normalized.startswith("kimi-k2.5")
+        or normalized.startswith("glm-5")
+    )
+
+
+def _model_prefers_responses(model: Optional[str]) -> bool:
+    normalized = str(model or "").strip().lower()
+    return normalized.startswith(("gpt-5", "o1", "o3", "o4"))
+
+
+def resolve_chat_transport(
+    base_url: Optional[str],
+    api_style: Optional[str] = "auto",
+    model: Optional[str] = None,
+    config: Any = None,
+) -> str:
+    style = normalize_api_style(api_style)
+    if style != "auto":
+        return style
+
+    if model:
+        try:
+            return resolve_model(config, str(model)).api_style
+        except (ValueError, TypeError):
+            pass
+
+    if _model_prefers_chat_completions(model):
+        return "chat_completions"
+    if _model_prefers_responses(model):
+        return "responses"
+
+    normalized = str(base_url or "").strip().rstrip("/")
+    if not normalized:
+        return "responses"
+
+    parsed = urlparse(normalized)
+    if "dashscope.aliyuncs.com" in (parsed.netloc or ""):
+        return "chat_completions"
+    return "responses"
+
+
+def ensure_default_max_output_tokens(
+    kwargs: Mapping[str, Any],
+    default_max_output_tokens: int,
+) -> Dict[str, Any]:
+    normalized = dict(kwargs)
+    has_token_limit = any(
+        key in normalized
+        for key in ("max_output_tokens", "max_tokens", "max_completion_tokens")
+    )
+    if not has_token_limit:
+        normalized["max_output_tokens"] = default_max_output_tokens
+    return normalized
+
+
+def normalize_responses_kwargs(
+    kwargs: Mapping[str, Any],
+    *,
+    strip_gpt_parameters: bool = False,
+) -> Dict[str, Any]:
+    normalized = dict(kwargs)
+    if "max_output_tokens" not in normalized:
+        if "max_completion_tokens" in normalized:
+            normalized["max_output_tokens"] = normalized.pop("max_completion_tokens")
+        elif "max_tokens" in normalized:
+            normalized["max_output_tokens"] = normalized.pop("max_tokens")
+    normalized.pop("max_completion_tokens", None)
+    normalized.pop("max_tokens", None)
+    if strip_gpt_parameters:
+        normalized.pop("reasoning", None)
+        normalized.pop("reasoning_effort", None)
+        normalized.pop("verbosity", None)
+        normalized.pop("service_tier", None)
+    return normalized
+
+
+def normalize_chat_completions_kwargs(
+    kwargs: Mapping[str, Any],
+    *,
+    strip_reasoning: bool = True,
+) -> Dict[str, Any]:
+    normalized = dict(kwargs)
+    if strip_reasoning:
+        normalized.pop("reasoning", None)
+        normalized.pop("reasoning_effort", None)
+        normalized.pop("verbosity", None)
+        normalized.pop("service_tier", None)
+        if "max_tokens" not in normalized and "max_completion_tokens" in normalized:
+            normalized["max_tokens"] = normalized.pop("max_completion_tokens")
+        else:
+            normalized.pop("max_completion_tokens", None)
+    if "max_tokens" not in normalized and "max_completion_tokens" not in normalized:
+        max_output_tokens = normalized.pop("max_output_tokens", None)
+        if max_output_tokens is not None:
+            normalized["max_tokens"] = max_output_tokens
+    else:
+        normalized.pop("max_output_tokens", None)
+    return normalized
+
+
+def clamp_chat_output_tokens(
+    config: Any,
+    model: str,
+    kwargs: Mapping[str, Any],
+) -> Dict[str, Any]:
+    normalized = dict(kwargs)
+    token_keys = ("max_output_tokens", "max_tokens", "max_completion_tokens")
+    for key in token_keys:
+        if key in normalized:
+            normalized[key] = clamp_output_tokens(config, model, normalized[key])
+            break
+    return normalized
+
+
+def extract_text_content(content: Any) -> str:
+    if isinstance(content, str):
+        return content.strip()
+    if not isinstance(content, list):
+        return ""
+
+    fragments = []
+    for part in content:
+        if isinstance(part, str):
+            if part.strip():
+                fragments.append(part.strip())
+            continue
+        if isinstance(part, Mapping):
+            part_type = str(part.get("type", "")).lower()
+            text = part.get("text")
+            if text and part_type in {"text", "output_text", "input_text"}:
+                fragments.append(str(text).strip())
+            continue
+        text = getattr(part, "text", None)
+        if text:
+            fragments.append(str(text).strip())
+
+    return "\n".join(fragment for fragment in fragments if fragment).strip()
+
+
+def extract_response_text(response: Any) -> str:
+    output_text = getattr(response, "output_text", None)
+    if isinstance(output_text, str) and output_text.strip():
+        return output_text.strip()
+
+    choices = getattr(response, "choices", None)
+    if choices:
+        message = getattr(choices[0], "message", None)
+        content = getattr(message, "content", None)
+        text = extract_text_content(content)
+        if text:
+            return text
+
+    output = getattr(response, "output", None)
+    if isinstance(output, list):
+        for item in output:
+            content = getattr(item, "content", None)
+            if content is None and isinstance(item, Mapping):
+                content = item.get("content")
+            text = extract_text_content(content)
+            if text:
+                return text
+
+    raise ValueError("LLM response did not include any text content.")

src/agents/idea_agent/utils/core/config_loader.py

@@ -0,0 +1,166 @@
+"""Configuration loading helpers for Idea Agent runtime defaults and overrides."""
+
+from __future__ import annotations
+
+import os
+import re
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any, Optional
+
+from omegaconf import OmegaConf
+
+DEFAULT_CONFIG_PATH = (
+    Path(__file__).resolve().parents[4] / "config" / "default.yaml"
+)
+REPO_ROOT = Path(__file__).resolve().parents[5]
+_REPO_ROOT_TOKEN = "__REPO_ROOT__"
+_WORKSPACE_TOKEN = "__WORKSPACE__"
+
+
+def _resolve_config_path(config_path: Optional[str]) -> Path:
+    if config_path:
+        path = Path(config_path)
+    else:
+        env_path = os.getenv("IDEA_AGENT_CONFIG")
+        path = Path(env_path) if env_path else DEFAULT_CONFIG_PATH
+    return path.expanduser().resolve()
+
+
+def _preprocess_yaml_content(content: str) -> str:
+    env_pattern = re.compile(r"\$\{env:([^}]+)\}")
+    content = env_pattern.sub(lambda match: os.environ.get(match.group(1), ""), content)
+
+    oc_env_pattern = re.compile(r"\$\{oc\.env:([^,}]+)(?:,([^}]*))?\}")
+    content = oc_env_pattern.sub(
+        lambda match: os.environ.get(match.group(1), match.group(2) or ""),
+        content,
+    )
+
+    content = content.replace("${repo_root}", _REPO_ROOT_TOKEN)
+    content = content.replace("${workspace}", _WORKSPACE_TOKEN)
+    return content
+
+
+def _load_yaml_config(path: Path) -> Any:
+    raw_content = _preprocess_yaml_content(path.read_text(encoding="utf-8"))
+    return OmegaConf.create(raw_content)
+
+
+def _recursive_apply(value: Any, transform) -> Any:
+    if OmegaConf.is_dict(value):
+        result = OmegaConf.create()
+        for key in value:
+            result[key] = _recursive_apply(value[key], transform)
+        return result
+    if OmegaConf.is_list(value):
+        return [_recursive_apply(item, transform) for item in value]
+    return transform(value)
+
+
+def _resolve_custom_placeholders(config: Any) -> Any:
+    repo_root = str(REPO_ROOT.resolve())
+    workspace_root = OmegaConf.select(config, "workspace.root")
+    if workspace_root is None:
+        workspace = str((REPO_ROOT / "workspace").resolve())
+    else:
+        workspace = str(workspace_root).replace(_REPO_ROOT_TOKEN, repo_root)
+
+    def _transform(value: Any) -> Any:
+        if isinstance(value, str):
+            return value.replace(_REPO_ROOT_TOKEN, repo_root).replace(_WORKSPACE_TOKEN, workspace)
+        return value
+
+    return _recursive_apply(config, _transform)
+
+
+def _load_defaults(defaults: list[Any], base_dir: Path) -> Any:
+    merged = OmegaConf.create()
+    for entry in defaults or []:
+        if isinstance(entry, str):
+            if entry in ("_self_", "self"):
+                continue
+            if "/" in entry:
+                group, name = entry.split("/", 1)
+                candidate = base_dir / group / f"{name}.yaml"
+            else:
+                candidate = base_dir / f"{entry}.yaml"
+        elif isinstance(entry, Mapping):
+            candidate = None
+            for group, name in entry.items():
+                if group in ("_self_", "self"):
+                    continue
+                candidate = base_dir / group / f"{name}.yaml"
+                break
+        else:
+            candidate = None
+
+        if candidate and candidate.exists():
+            merged = OmegaConf.merge(merged, _load_yaml_config(candidate))
+    return merged
+
+
+def load_project_config(config_path: Optional[str] = None) -> Any:
+    path = _resolve_config_path(config_path)
+    if not path.exists():
+        raise FileNotFoundError(f"Idea agent config not found at {path}")
+    config = _load_yaml_config(path)
+    defaults = config.get("defaults") if isinstance(config, dict) or hasattr(config, "get") else None
+    if not defaults:
+        return _resolve_custom_placeholders(config)
+    merged = _load_defaults(defaults, path.parent)
+    without_defaults = OmegaConf.create({k: v for k, v in config.items() if k != "defaults"})
+    return _resolve_custom_placeholders(OmegaConf.merge(merged, without_defaults))
+
+
+def load_idea_agent_config(config_path: Optional[str] = None) -> Any:
+    config = load_project_config(config_path)
+    idea_config = config.get("idea") if hasattr(config, "get") else None
+    if idea_config is not None:
+        return idea_config
+    return config
+
+
+def get_config_value(config: Optional[Any], key: str, default: Any) -> Any:
+    if config is None:
+        return default
+    try:
+        value = OmegaConf.select(config, key)
+    except Exception:
+        value = None
+    return default if value is None else value
+
+
+def get_workspace_root(config: Optional[Any] = None) -> Path:
+    workspace_root = get_config_value(config, "workspace.root", None)
+    if workspace_root in (None, "", "None"):
+        try:
+            project_config = load_project_config()
+        except Exception:
+            project_config = None
+        workspace_root = get_config_value(project_config, "workspace.root", None)
+    if workspace_root in (None, "", "None"):
+        return (REPO_ROOT / "workspace").resolve()
+    return Path(str(workspace_root)).expanduser().resolve()
+
+
+def resolve_workspace_path(path_value: Any, config: Optional[Any] = None) -> str:
+    raw = str(path_value or "").strip()
+    if not raw:
+        return raw
+    candidate = Path(raw).expanduser()
+    if candidate.is_absolute():
+        return str(candidate.resolve())
+
+    repo_root = REPO_ROOT.resolve()
+    workspace_root = get_workspace_root(config)
+
+    for root in (repo_root, workspace_root):
+        resolved = (root / candidate).resolve()
+        if resolved.exists():
+            return str(resolved)
+
+    repo_relative_roots = {"src", "models", "data", "database", "docs", "graph", "tests"}
+    anchor = candidate.parts[0] if candidate.parts else ""
+    base_dir = repo_root if anchor in repo_relative_roots else workspace_root
+    return str((base_dir / candidate).resolve())

src/agents/idea_agent/utils/core/json_utils.py

@@ -0,0 +1,28 @@
+"""Shared JSON formatting and file helpers for Idea Agent."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+def pretty_json(value: Any) -> str:
+    return json.dumps(value, ensure_ascii=False, indent=2)
+
+
+def compact_json(value: Any, *, sort_keys: bool = False) -> str:
+    return json.dumps(
+        value,
+        ensure_ascii=False,
+        separators=(",", ":"),
+        sort_keys=sort_keys,
+    )
+
+
+def read_json_file(path: Path) -> Any:
+    return json.loads(Path(path).read_text(encoding="utf-8"))
+
+
+def write_json_file(path: Path, payload: Any) -> None:
+    Path(path).write_text(pretty_json(payload) + "\n", encoding="utf-8")