self-evolve-framework 1.6.0 → 1.6.1

package/template/skills/skillopt-sleep/scripts/framework/skillopt/model/common.py

@@ -1,229 +0,0 @@
-"""Shared model utilities for ReflACT backends."""
-from __future__ import annotations
-
-import json
-import threading
-from dataclasses import dataclass, field
-from typing import Any
-
-
-_RESPONSES_API_MODELS = {
-    "gpt-5.3-codex",
-    "gpt-5.1-codex",
-    "gpt-5.2-codex",
-    "gpt-5-codex",
-    "codex-mini",
-    "gpt-5.4-pro",
-}
-
-_BACKEND_DEFAULT_MODELS = {
-    "azure_openai": "gpt-4o",
-    "openai_chat": "gpt-4o",
-    "codex": "gpt-4o",
-    "codex_exec": "gpt-4o",
-    "claude": "claude-sonnet-4-6",
-    "claude_chat": "claude-sonnet-4-6",
-    "claude_code_exec": "claude-sonnet-4-6",
-    "qwen_chat": "Qwen/Qwen3.5-4B",
-    "minimax_chat": "MiniMax-M2.7",
-}
-
-_BACKEND_ALIASES = {
-    "azure": "azure_openai",
-    "azure_openai": "azure_openai",
-    "azure-openai": "azure_openai",
-    "openai_chat": "openai_chat",
-    "openai": "codex",
-    "codex": "codex",
-    "codex_exec": "codex_exec",
-    "claude": "claude_chat",
-    "claude_chat": "claude_chat",
-    "claude_code_exec": "claude_code_exec",
-    "anthropic": "claude_chat",
-    "qwen": "qwen_chat",
-    "qwen_chat": "qwen_chat",
-    "minimax": "minimax_chat",
-    "minimax_chat": "minimax_chat",
-}
-
-
-def normalize_backend_name(name: str | None) -> str:
-    normalized = str(name or "").strip().lower()
-    return _BACKEND_ALIASES.get(normalized, normalized or "azure_openai")
-
-
-def default_model_for_backend(backend: str | None) -> str:
-    return _BACKEND_DEFAULT_MODELS.get(
-        normalize_backend_name(backend),
-        _BACKEND_DEFAULT_MODELS["azure_openai"],
-    )
-
-
-def needs_responses_api(model: str) -> bool:
-    normalized = str(model or "").strip().lower()
-    return any(
-        normalized == prefix or normalized.startswith(prefix + "-")
-        for prefix in _RESPONSES_API_MODELS
-    )
-
-
-class TokenTracker:
-    def __init__(self) -> None:
-        self._lock = threading.Lock()
-        self._data: dict[str, dict[str, int]] = {}
-
-    def record(self, stage: str, prompt_tokens: int, completion_tokens: int) -> None:
-        with self._lock:
-            if stage not in self._data:
-                self._data[stage] = {
-                    "calls": 0,
-                    "prompt_tokens": 0,
-                    "completion_tokens": 0,
-                }
-            entry = self._data[stage]
-            entry["calls"] += 1
-            entry["prompt_tokens"] += prompt_tokens
-            entry["completion_tokens"] += completion_tokens
-
-    def summary(self) -> dict[str, dict[str, int]]:
-        with self._lock:
-            out: dict[str, dict[str, int]] = {}
-            total_prompt = total_completion = total_calls = 0
-            for stage, entry in sorted(self._data.items()):
-                prompt_tokens = entry["prompt_tokens"]
-                completion_tokens = entry["completion_tokens"]
-                out[stage] = {
-                    "calls": entry["calls"],
-                    "prompt_tokens": prompt_tokens,
-                    "completion_tokens": completion_tokens,
-                    "total_tokens": prompt_tokens + completion_tokens,
-                }
-                total_prompt += prompt_tokens
-                total_completion += completion_tokens
-                total_calls += entry["calls"]
-            out["_total"] = {
-                "calls": total_calls,
-                "prompt_tokens": total_prompt,
-                "completion_tokens": total_completion,
-                "total_tokens": total_prompt + total_completion,
-            }
-            return out
-
-    def reset(self) -> None:
-        with self._lock:
-            self._data.clear()
-
-
-tracker = TokenTracker()
-
-
-@dataclass
-class CompatToolFunction:
-    name: str
-    arguments: str
-
-    def model_dump(self, mode: str = "json") -> dict[str, str]:
-        del mode
-        return {
-            "name": self.name,
-            "arguments": self.arguments,
-        }
-
-
-@dataclass
-class CompatToolCall:
-    id: str
-    function: CompatToolFunction
-    type: str = "function"
-
-    def model_dump(self, mode: str = "json") -> dict[str, Any]:
-        del mode
-        return {
-            "id": self.id,
-            "type": self.type,
-            "function": self.function.model_dump(),
-        }
-
-
-@dataclass
-class CompatAssistantMessage:
-    content: str
-    tool_calls: list[CompatToolCall] = field(default_factory=list)
-    metadata: dict[str, Any] = field(default_factory=dict)
-
-    def model_dump(self, mode: str = "json") -> dict[str, Any]:
-        del mode
-        data: dict[str, Any] = {"role": "assistant", "content": self.content}
-        if self.tool_calls:
-            data["tool_calls"] = [tool_call.model_dump() for tool_call in self.tool_calls]
-        return data
-
-
-def usage_from_openai_usage(usage: Any) -> dict[str, int]:
-    if not usage:
-        return {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
-    prompt_tokens = getattr(usage, "prompt_tokens", 0) or 0
-    completion_tokens = getattr(usage, "completion_tokens", 0) or 0
-    total_tokens = getattr(usage, "total_tokens", 0) or (prompt_tokens + completion_tokens)
-    return {
-        "prompt_tokens": prompt_tokens,
-        "completion_tokens": completion_tokens,
-        "total_tokens": total_tokens,
-    }
-
-
-def usage_from_responses_usage(usage: Any) -> dict[str, int]:
-    if not usage:
-        return {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
-    prompt_tokens = getattr(usage, "input_tokens", 0) or 0
-    completion_tokens = getattr(usage, "output_tokens", 0) or 0
-    return {
-        "prompt_tokens": prompt_tokens,
-        "completion_tokens": completion_tokens,
-        "total_tokens": prompt_tokens + completion_tokens,
-    }
-
-
-def compat_message_from_chat_message(message: Any) -> CompatAssistantMessage:
-    content = getattr(message, "content", "") or ""
-    tool_calls = []
-    for tool_call in getattr(message, "tool_calls", None) or []:
-        function = getattr(tool_call, "function", None)
-        tool_calls.append(
-            CompatToolCall(
-                id=getattr(tool_call, "id", "") or "",
-                function=CompatToolFunction(
-                    name=getattr(function, "name", "") or "",
-                    arguments=getattr(function, "arguments", "") or "{}",
-                ),
-            )
-        )
-    return CompatAssistantMessage(content=content, tool_calls=tool_calls)
-
-
-def compat_message_from_responses_output(output: list[Any]) -> CompatAssistantMessage:
-    text_parts: list[str] = []
-    tool_calls: list[CompatToolCall] = []
-    for item in output:
-        item_type = getattr(item, "type", "") or ""
-        if item_type == "function_call":
-            raw_arguments = getattr(item, "arguments", None)
-            if raw_arguments is None:
-                raw_arguments = json.dumps(getattr(item, "input", {}) or {})
-            tool_calls.append(
-                CompatToolCall(
-                    id=getattr(item, "call_id", "") or getattr(item, "id", "") or "",
-                    function=CompatToolFunction(
-                        name=getattr(item, "name", "") or "",
-                        arguments=str(raw_arguments or "{}"),
-                    ),
-                )
-            )
-            continue
-        if item_type != "message":
-            continue
-        for part in getattr(item, "content", []) or []:
-            part_type = getattr(part, "type", "") or ""
-            if part_type in {"output_text", "text"}:
-                text_parts.append(getattr(part, "text", "") or "")
-    return CompatAssistantMessage(content="".join(text_parts), tool_calls=tool_calls)

package/template/skills/skillopt-sleep/scripts/framework/skillopt/model/minimax_backend.py

@@ -1,277 +0,0 @@
-"""OpenAI-compatible MiniMax chat backend for the target path."""
-from __future__ import annotations
-
-import json
-import os
-import threading
-import time
-import urllib.error
-import urllib.request
-from typing import Any
-
-from skillopt.model.common import (
-    CompatAssistantMessage,
-    CompatToolCall,
-    CompatToolFunction,
-    TokenTracker,
-    default_model_for_backend,
-)
-
-BASE_URL = os.environ.get("MINIMAX_BASE_URL", "https://api.minimax.io/v1")
-API_KEY = os.environ.get("MINIMAX_API_KEY", "")
-TIMEOUT_SECONDS = float(os.environ.get("MINIMAX_TIMEOUT_SECONDS", "300") or 300)
-MAX_TOKENS = int(os.environ.get("MINIMAX_MAX_TOKENS", "8000") or 8000)
-TEMPERATURE: float | None = None
-_raw_temperature = os.environ.get("MINIMAX_TEMPERATURE", "0.7").strip()
-if _raw_temperature:
-    TEMPERATURE = float(_raw_temperature)
-ENABLE_THINKING = os.environ.get("MINIMAX_ENABLE_THINKING", "false").strip().lower() in {
-    "1",
-    "true",
-    "yes",
-    "on",
-}
-
-TARGET_DEPLOYMENT = os.environ.get(
-    "TARGET_DEPLOYMENT",
-    default_model_for_backend("minimax_chat"),
-)
-
-_config_lock = threading.Lock()
-tracker = TokenTracker()
-
-
-def _chat_url() -> str:
-    base = BASE_URL.rstrip("/")
-    if base.endswith("/chat/completions"):
-        return base
-    return f"{base}/chat/completions"
-
-
-def _json_safe(value: Any) -> Any:
-    if value is None or isinstance(value, (str, int, float, bool)):
-        return value
-    if isinstance(value, list):
-        return [_json_safe(item) for item in value]
-    if isinstance(value, dict):
-        return {str(key): _json_safe(val) for key, val in value.items()}
-    model_dump = getattr(value, "model_dump", None)
-    if callable(model_dump):
-        try:
-            return model_dump(mode="json")
-        except TypeError:
-            return model_dump()
-    return str(value)
-
-
-def _usage_from_payload(payload: dict[str, Any]) -> dict[str, int]:
-    usage = payload.get("usage") or {}
-    prompt_tokens = int(usage.get("prompt_tokens") or usage.get("input_tokens") or 0)
-    completion_tokens = int(usage.get("completion_tokens") or usage.get("output_tokens") or 0)
-    total_tokens = int(usage.get("total_tokens") or (prompt_tokens + completion_tokens))
-    return {
-        "prompt_tokens": prompt_tokens,
-        "completion_tokens": completion_tokens,
-        "total_tokens": total_tokens,
-    }
-
-
-def _compat_message_from_payload(message: dict[str, Any], choice: dict[str, Any]) -> CompatAssistantMessage:
-    content = message.get("content") or ""
-    if not isinstance(content, str):
-        content = json.dumps(content, ensure_ascii=False)
-    tool_calls: list[CompatToolCall] = []
-    for index, tool_call in enumerate(message.get("tool_calls") or [], start=1):
-        function = tool_call.get("function") or {}
-        tool_calls.append(
-            CompatToolCall(
-                id=str(tool_call.get("id") or f"minimax_tool_{index}"),
-                type=str(tool_call.get("type") or "function"),
-                function=CompatToolFunction(
-                    name=str(function.get("name") or ""),
-                    arguments=str(function.get("arguments") or "{}"),
-                ),
-            )
-        )
-    return CompatAssistantMessage(
-        content=content,
-        tool_calls=tool_calls,
-        metadata={
-            "finish_reason": choice.get("finish_reason"),
-            "choice0": _json_safe(choice),
-        },
-    )
-
-
-def _post_chat_completion(payload: dict[str, Any], timeout: float | None) -> dict[str, Any]:
-    headers = {"Content-Type": "application/json"}
-    if API_KEY:
-        headers["Authorization"] = f"Bearer {API_KEY}"
-    req = urllib.request.Request(
-        _chat_url(),
-        data=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
-        headers=headers,
-        method="POST",
-    )
-    try:
-        with urllib.request.urlopen(req, timeout=timeout or TIMEOUT_SECONDS) as resp:
-            raw = resp.read().decode("utf-8")
-    except urllib.error.HTTPError as e:
-        body = e.read().decode("utf-8", errors="replace")
-        raise RuntimeError(f"MiniMax chat API returned HTTP {e.code}: {body}") from e
-    except urllib.error.URLError as e:
-        raise RuntimeError(f"MiniMax chat API request failed: {e}") from e
-    try:
-        return json.loads(raw)
-    except json.JSONDecodeError as e:
-        raise RuntimeError(f"MiniMax chat API returned non-JSON response: {raw[:1000]}") from e
-
-
-def _chat_messages_impl(
-    messages: list[dict[str, Any]],
-    max_completion_tokens: int,
-    retries: int,
-    stage: str,
-    *,
-    tools: list[dict[str, Any]] | None = None,
-    tool_choice: str | dict[str, Any] | None = None,
-    return_message: bool = False,
-    deployment: str | None = None,
-    timeout: float | None = None,
-) -> tuple[Any, dict[str, int]]:
-    payload: dict[str, Any] = {
-        "model": deployment or TARGET_DEPLOYMENT,
-        "messages": _json_safe(messages),
-        "max_tokens": min(max_completion_tokens, MAX_TOKENS),
-    }
-    payload["chat_template_kwargs"] = {"enable_thinking": ENABLE_THINKING}
-    if TEMPERATURE is not None:
-        payload["temperature"] = TEMPERATURE
-    if tools:
-        payload["tools"] = _json_safe(tools)
-        if tool_choice is not None:
-            payload["tool_choice"] = _json_safe(tool_choice)
-
-    last_err: Exception | None = None
-    for attempt in range(retries):
-        try:
-            data = _post_chat_completion(payload, timeout)
-            choices = data.get("choices") or []
-            if not choices:
-                raise RuntimeError(f"MiniMax chat API returned no choices: {data}")
-            choice0 = choices[0]
-            message = choice0.get("message") or {}
-            text = message.get("content") or ""
-            if not isinstance(text, str):
-                text = json.dumps(text, ensure_ascii=False)
-            usage_info = _usage_from_payload(data)
-            tracker.record(stage, usage_info["prompt_tokens"], usage_info["completion_tokens"])
-            if return_message:
-                return _compat_message_from_payload(message, choice0), usage_info
-            return text, usage_info
-        except Exception as e:  # noqa: BLE001
-            last_err = e
-            time.sleep(min(2 ** attempt, 30))
-    raise RuntimeError(f"MiniMax chat call failed after {retries} retries: {last_err}")
-
-
-def configure_minimax_chat(
-    *,
-    base_url: str | None = None,
-    api_key: str | None = None,
-    temperature: float | str | None = None,
-    timeout_seconds: float | str | None = None,
-    max_tokens: int | str | None = None,
-    enable_thinking: bool | str | None = None,
-) -> None:
-    global BASE_URL, API_KEY, TEMPERATURE, TIMEOUT_SECONDS, MAX_TOKENS, ENABLE_THINKING
-    with _config_lock:
-        if base_url is not None:
-            BASE_URL = str(base_url).strip() or BASE_URL
-            os.environ["MINIMAX_BASE_URL"] = BASE_URL
-        if api_key is not None:
-            API_KEY = str(api_key).strip()
-            os.environ["MINIMAX_API_KEY"] = API_KEY
-        if temperature is not None:
-            raw = str(temperature).strip()
-            TEMPERATURE = float(raw) if raw else None
-            os.environ["MINIMAX_TEMPERATURE"] = raw
-        if timeout_seconds is not None:
-            TIMEOUT_SECONDS = float(timeout_seconds)
-            os.environ["MINIMAX_TIMEOUT_SECONDS"] = str(timeout_seconds)
-        if max_tokens is not None:
-            MAX_TOKENS = int(max_tokens)
-            os.environ["MINIMAX_MAX_TOKENS"] = str(max_tokens)
-        if enable_thinking is not None:
-            if isinstance(enable_thinking, str):
-                ENABLE_THINKING = enable_thinking.strip().lower() in {"1", "true", "yes", "on"}
-            else:
-                ENABLE_THINKING = bool(enable_thinking)
-            os.environ["MINIMAX_ENABLE_THINKING"] = "true" if ENABLE_THINKING else "false"
-
-
-def get_max_tokens() -> int:
-    return MAX_TOKENS
-
-
-def chat_target(
-    system: str,
-    user: str,
-    max_completion_tokens: int = 16384,
-    retries: int = 5,
-    stage: str = "target",
-    reasoning_effort: str | None = None,
-    timeout: float | None = None,
-) -> tuple[str, dict[str, int]]:
-    del reasoning_effort
-    messages = [{"role": "system", "content": system}, {"role": "user", "content": user}]
-    return _chat_messages_impl(
-        messages,
-        max_completion_tokens,
-        retries,
-        stage,
-        timeout=timeout,
-    )
-
-
-def chat_target_messages(
-    messages: list[dict[str, Any]],
-    max_completion_tokens: int = 16384,
-    retries: int = 5,
-    stage: str = "target",
-    reasoning_effort: str | None = None,
-    *,
-    tools: list[dict[str, Any]] | None = None,
-    tool_choice: str | dict[str, Any] | None = None,
-    return_message: bool = False,
-    timeout: float | None = None,
-) -> tuple[Any, dict[str, int]]:
-    del reasoning_effort
-    return _chat_messages_impl(
-        messages,
-        max_completion_tokens,
-        retries,
-        stage,
-        tools=tools,
-        tool_choice=tool_choice,
-        return_message=return_message,
-        timeout=timeout,
-    )
-
-
-def get_token_summary() -> dict[str, dict[str, int]]:
-    return tracker.summary()
-
-
-def reset_token_tracker() -> None:
-    tracker.reset()
-
-
-def set_reasoning_effort(effort: str | None) -> None:
-    del effort
-
-
-def set_target_deployment(deployment: str) -> None:
-    global TARGET_DEPLOYMENT
-    TARGET_DEPLOYMENT = deployment or default_model_for_backend("minimax_chat")
-    os.environ["TARGET_DEPLOYMENT"] = TARGET_DEPLOYMENT