self-evolve-framework 1.5.0 → 1.6.0

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

@@ -0,0 +1,229 @@
+"""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

@@ -0,0 +1,277 @@
+"""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