Skip to content

Create, Evaluate, and Connect AI Skills

feat: add MiniMax as first-class LLM provider

PR Botfc363763e70d
diff --git a/README.md b/README.md
index eda76b2..f9ad662 100644
--- a/README.md
+++ b/README.md
@@ -312,6 +312,7 @@ skillnet analyze ./my_agent_skills --model gpt-4o
| Variable | Required For | Default |
| :--------------- | :--------------------------------- | :-------------------------- |
| `API_KEY` | `create` · `evaluate` · `analyze` | — |
+| `MINIMAX_API_KEY`| MiniMax provider (auto-detected) | — |
| `BASE_URL` | Custom LLM endpoint | `https://api.openai.com/v1` |
| `GITHUB_TOKEN` | Private repos / higher rate limits | — |
| `SKILLNET_MODEL` | Default LLM model for all commands | `gpt-4o` |
@@ -335,6 +336,51 @@ $env:API_KEY = "sk-..."
$env:BASE_URL = "https://..." # optional
```
+### Using MiniMax as LLM Provider
+
+SkillNet supports [MiniMax](https://www.minimax.io/) as a first-class LLM provider. MiniMax offers the M2.7 model with a 1M-token context window and OpenAI-compatible API.
+
+**Quick start — environment variable (auto-detected):**
+
+```bash
+export MINIMAX_API_KEY="your-minimax-api-key"
+skillnet create --prompt "A skill for web scraping"
+# Provider, base URL, and model are auto-configured
+```
+
+**Explicit provider flag:**
+
+```bash
+export MINIMAX_API_KEY="your-minimax-api-key"
+skillnet create --provider minimax --prompt "A skill for web scraping"
+skillnet evaluate --provider minimax ./my_skill
+skillnet analyze --provider minimax ./my_skills
+```
+
+**Python SDK:**
+
+```python
+from skillnet_ai import SkillNetClient
+
+# Auto-detected when MINIMAX_API_KEY is set
+client = SkillNetClient()
+
+# Or explicit provider
+client = SkillNetClient(
+ provider="minimax",
+ api_key="your-minimax-api-key",
+)
+
+# All operations use MiniMax M2.7 by default
+client.create(prompt="A skill for PDF parsing", output_dir="./skills")
+client.evaluate(target="./skills/pdf-parser")
+```
+
+| Provider | Default Model | Base URL | API Key Env |
+| :------- | :--------------- | :---------------------------- | :----------------- |
+| `openai` | `gpt-4o` | `https://api.openai.com/v1` | `API_KEY` |
+| `minimax`| `MiniMax-M2.7` | `https://api.minimax.io/v1` | `MINIMAX_API_KEY` |
+
---
## 🔬 Example: Scientific Discovery
diff --git a/skillnet-ai/src/skillnet_ai/__init__.py b/skillnet-ai/src/skillnet_ai/__init__.py
index 0c8038a..b3d6242 100644
--- a/skillnet-ai/src/skillnet_ai/__init__.py
+++ b/skillnet-ai/src/skillnet_ai/__init__.py
@@ -11,6 +11,12 @@ from skillnet_ai.downloader import SkillDownloader
from skillnet_ai.evaluator import SkillEvaluator, EvaluatorConfig
from skillnet_ai.searcher import SkillNetSearcher
from skillnet_ai.analyzer import SkillRelationshipAnalyzer
+from skillnet_ai.providers import (
+ PROVIDER_PRESETS,
+ SUPPORTED_PROVIDERS,
+ get_provider_preset,
+ detect_provider,
+)
__all__ = [
"SkillNetClient",
@@ -19,5 +25,9 @@ __all__ = [
"SkillEvaluator",
"EvaluatorConfig",
"SkillNetSearcher",
- "SkillRelationshipAnalyzer"
+ "SkillRelationshipAnalyzer",
+ "PROVIDER_PRESETS",
+ "SUPPORTED_PROVIDERS",
+ "get_provider_preset",
+ "detect_provider",
]
\ No newline at end of file
diff --git a/skillnet-ai/src/skillnet_ai/analyzer.py b/skillnet-ai/src/skillnet_ai/analyzer.py
index 468548c..f353343 100644
--- a/skillnet-ai/src/skillnet_ai/analyzer.py
+++ b/skillnet-ai/src/skillnet_ai/analyzer.py
@@ -9,13 +9,18 @@ from skillnet_ai.prompts import (
RELATIONSHIP_ANALYSIS_SYSTEM_PROMPT,
RELATIONSHIP_ANALYSIS_USER_PROMPT_TEMPLATE
)
+from skillnet_ai.providers import (
+ resolve_provider_config,
+ postprocess_response,
+ ProviderPreset,
+)
logger = logging.getLogger(__name__)
class SkillRelationshipAnalyzer:
"""
Analyzes a directory of skills to determine relationships between them.
-
+
Relationships determined:
- similar_to: A and B are functionally similar and interchangeable.
- belong_to: A is a sub-task/part of B (B is the larger scope).
@@ -23,14 +28,24 @@ class SkillRelationshipAnalyzer:
- depend_on: A requires B to execute (prerequisite).
"""
- def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None, model: str = "gpt-4o"):
- self.api_key = api_key or os.getenv("API_KEY")
- self.base_url = base_url or os.getenv("BASE_URL") or "https://api.openai.com/v1"
- self.model = model
-
+ def __init__(
+ self,
+ api_key: Optional[str] = None,
+ base_url: Optional[str] = None,
+ model: Optional[str] = None,
+ provider: Optional[str] = None,
+ ):
+ cfg = resolve_provider_config(
+ provider=provider, api_key=api_key, base_url=base_url, model=model
+ )
+ self.api_key = cfg["api_key"]
+ self.base_url = cfg["base_url"]
+ self.model = cfg["model"]
+ self._preset: Optional[ProviderPreset] = cfg["preset"]
+
if not self.api_key:
raise ValueError("API Key is missing. Please provide it in init or set API_KEY environment variable.")
-
+
self.client = OpenAI(api_key=self.api_key, base_url=self.base_url)
def analyze_local_skills(self, skills_dir: str, save_to_file: bool = True) -> List[Dict[str, Any]]:
@@ -168,6 +183,8 @@ class SkillRelationshipAnalyzer:
messages=messages,
)
content = response.choices[0].message.content
+ if self._preset:
+ content = postprocess_response(content, self._preset)
# 1. Extract JSON from tags
json_str = self._extract_json_from_tags(content, "Skill_Relationships")
diff --git a/skillnet-ai/src/skillnet_ai/cli.py b/skillnet-ai/src/skillnet_ai/cli.py
index d50608d..3bd1774 100644
--- a/skillnet-ai/src/skillnet_ai/cli.py
+++ b/skillnet-ai/src/skillnet_ai/cli.py
@@ -10,6 +10,7 @@ from skillnet_ai.downloader import SkillDownloader, GitHubAPIError
from skillnet_ai.evaluator import SkillEvaluator, EvaluatorConfig
from skillnet_ai.searcher import SkillNetSearcher
from skillnet_ai.analyzer import SkillRelationshipAnalyzer
+from skillnet_ai.providers import resolve_provider_config, SUPPORTED_PROVIDERS
app = typer.Typer(help="SkillNet AI CLI Tool")
console = Console()
@@ -183,10 +184,11 @@ def create(
# Model options
model: str = typer.Option(DEFAULT_MODEL, "--model", "-m", help="LLM model to use (e.g., gpt-4o, gpt-3.5-turbo)."),
max_files: int = typer.Option(50, "--max-files", help="Max code files to analyze (--github only)."),
+ provider: str = typer.Option(None, "--provider", help=f"LLM provider ({', '.join(SUPPORTED_PROVIDERS)}). Auto-detected when omitted."),
):
"""
Create executable Skill packages using AI.
-
+
Supports four modes:
- From trajectory: skillnet create trajectory.txt
- From GitHub: skillnet create --github https://github.com/owner/repo
@@ -194,9 +196,10 @@ def create(
- From prompt: skillnet create --prompt "Create a skill for..."
"""
# 1. Validate Environment
- if not API_KEY:
- console.print("[bold red]Error:[/bold red] API_KEY environment variable is not set.")
- console.print("Please export API_KEY or set it in your environment.")
+ cfg = resolve_provider_config(provider=provider, api_key=API_KEY, base_url=BASE_URL, model=model)
+ if not cfg["api_key"]:
+ console.print("[bold red]Error:[/bold red] API key is not set.")
+ console.print("Set API_KEY (OpenAI) or MINIMAX_API_KEY (MiniMax), or pass --provider.")
raise typer.Exit(code=1)
# 2. Determine mode based on provided options
@@ -222,16 +225,16 @@ def create(
# 3. Route to appropriate handler
if github:
- _create_from_github(github, output_dir, model, max_files)
+ _create_from_github(github, output_dir, model, max_files, provider)
elif trajectory_file:
- _create_from_trajectory(trajectory_file, output_dir, model)
+ _create_from_trajectory(trajectory_file, output_dir, model, provider)
elif office:
- _create_from_office(office, output_dir, model)
+ _create_from_office(office, output_dir, model, provider)
elif prompt:
- _create_from_prompt(prompt, output_dir, model)
+ _create_from_prompt(prompt, output_dir, model, provider)
-def _create_from_trajectory(trajectory_file: Path, output_dir: Path, model: str):
+def _create_from_trajectory(trajectory_file: Path, output_dir: Path, model: str, provider: str = None):
"""Internal function to create skill from trajectory file."""
try:
# Read Trajectory Content
@@ -245,9 +248,10 @@ def _create_from_trajectory(trajectory_file: Path, output_dir: Path, model: str)
# Initialize Creator
creator = SkillCreator(
- api_key=API_KEY,
- base_url=BASE_URL,
- model=model
+ api_key=API_KEY,
+ base_url=BASE_URL,
+ model=model,
+ provider=provider,
)
# Run Generation with Spinner
@@ -260,7 +264,7 @@ def _create_from_trajectory(trajectory_file: Path, output_dir: Path, model: str)
# Report Results
if created_paths:
console.print(f"\n[bold green]Success! Generated {len(created_paths)} skill(s):[/bold green]")
-
+
table = Table(show_header=True, header_style="bold magenta")
table.add_column("Skill Name", style="cyan")
table.add_column("Location", style="white")
@@ -268,7 +272,7 @@ def _create_from_trajectory(trajectory_file: Path, output_dir: Path, model: str)
for path in created_paths:
skill_name = os.path.basename(path)
table.add_row(skill_name, str(path))
-
+
console.print(table)
console.print(f"\n[dim]Files saved to: {os.path.abspath(output_dir)}[/dim]")
else:
@@ -279,7 +283,7 @@ def _create_from_trajectory(trajectory_file: Path, output_dir: Path, model: str)
raise typer.Exit(code=1)
-def _create_from_github(github_url: str, output_dir: Path, model: str, max_files: int):
+def _create_from_github(github_url: str, output_dir: Path, model: str, max_files: int, provider: str = None):
"""Internal function to create skill from GitHub repository."""
try:
console.print(f"[dim]Creating skill from GitHub: {github_url}[/dim]")
@@ -288,7 +292,8 @@ def _create_from_github(github_url: str, output_dir: Path, model: str, max_files
creator = SkillCreator(
api_key=API_KEY,
base_url=BASE_URL,
- model=model
+ model=model,
+ provider=provider,
)
# Run Generation with Spinner
@@ -303,7 +308,7 @@ def _create_from_github(github_url: str, output_dir: Path, model: str, max_files
# Report Results
if created_paths:
console.print(f"\n[bold green]Success! Generated {len(created_paths)} skill(s) from GitHub:[/bold green]")
-
+
table = Table(show_header=True, header_style="bold magenta")
table.add_column("Skill Name", style="cyan")
table.add_column("Location", style="white")
@@ -311,7 +316,7 @@ def _create_from_github(github_url: str, output_dir: Path, model: str, max_files
for path in created_paths:
skill_name = os.path.basename(path)
table.add_row(skill_name, str(path))
-
+
console.print(table)
console.print(f"\n[dim]Files saved to: {os.path.abspath(output_dir)}[/dim]")
console.print("\n[dim]Tip: Use 'skillnet evaluate <skill_path>' to evaluate the generated skill.[/dim]")
@@ -323,7 +328,7 @@ def _create_from_github(github_url: str, output_dir: Path, model: str, max_files
raise typer.Exit(code=1)
-def _create_from_office(office_file: Path, output_dir: Path, model: str):
+def _create_from_office(office_file: Path, output_dir: Path, model: str, provider: str = None):
"""Internal function to create skill from office document."""
try:
console.print(f"[dim]Creating skill from office document: {office_file}[/dim]")
@@ -332,7 +337,8 @@ def _create_from_office(office_file: Path, output_dir: Path, model: str):
creator = SkillCreator(
api_key=API_KEY,
base_url=BASE_URL,
- model=model
+ model=model,
+ provider=provider,
)
# Run Generation with Spinner
@@ -345,7 +351,7 @@ def _create_from_office(office_file: Path, output_dir: Path, model: str):
# Report Results
if created_paths:
console.print(f"\n[bold green]Success! Generated {len(created_paths)} skill(s) from document:[/bold green]")
-
+
table = Table(show_header=True, header_style="bold magenta")
table.add_column("Skill Name", style="cyan")
table.add_column("Location", style="white")
@@ -353,7 +359,7 @@ def _create_from_office(office_file: Path, output_dir: Path, model: str):
for path in created_paths:
skill_name = os.path.basename(path)
table.add_row(skill_name, str(path))
-
+
console.print(table)
console.print(f"\n[dim]Files saved to: {os.path.abspath(output_dir)}[/dim]")
console.print("\n[dim]Tip: Use 'skillnet evaluate <skill_path>' to evaluate the generated skill.[/dim]")
@@ -370,7 +376,7 @@ def _create_from_office(office_file: Path, output_dir: Path, model: str):
raise typer.Exit(code=1)
-def _create_from_prompt(user_prompt: str, output_dir: Path, model: str):
+def _create_from_prompt(user_prompt: str, output_dir: Path, model: str, provider: str = None):
"""Internal function to create skill from user's prompt description."""
try:
console.print(f"[dim]Creating skill from user prompt...[/dim]")
@@ -379,7 +385,8 @@ def _create_from_prompt(user_prompt: str, output_dir: Path, model: str):
creator = SkillCreator(
api_key=API_KEY,
base_url=BASE_URL,
- model=model
+ model=model,
+ provider=provider,
)
# Run Generation with Spinner
@@ -424,23 +431,27 @@ def evaluate(
# Config options
model: str = typer.Option(DEFAULT_MODEL, "--model", "-m", help="LLM model to use."),
max_workers: int = typer.Option(5, help="Concurrency for batch operations (not used for single eval)."),
+ provider: str = typer.Option(None, "--provider", help=f"LLM provider ({', '.join(SUPPORTED_PROVIDERS)}). Auto-detected when omitted."),
):
"""
Evaluate the quality, safety, and completeness of a skill using AI.
-
+
Target can be a local folder path or a GitHub URL (e.g., https://github.com/user/repo/tree/main/skill).
"""
# 1. Validate Environment
- if not API_KEY:
- console.print("[bold red]Error:[/bold red] API_KEY environment variable is not set.")
+ cfg = resolve_provider_config(provider=provider, api_key=API_KEY, base_url=BASE_URL, model=model)
+ if not cfg["api_key"]:
+ console.print("[bold red]Error:[/bold red] API key is not set.")
+ console.print("Set API_KEY (OpenAI) or MINIMAX_API_KEY (MiniMax), or pass --provider.")
raise typer.Exit(code=1)
# 2. Configure Evaluator
config = EvaluatorConfig(
- api_key=API_KEY,
- base_url=BASE_URL,
- model=model,
- max_workers=max_workers
+ api_key=cfg["api_key"],
+ base_url=cfg["base_url"],
+ model=cfg["model"],
+ max_workers=max_workers,
+ provider=provider,
)
evaluator = SkillEvaluator(config)
@@ -517,24 +528,28 @@ def analyze(
skills_dir: Path = typer.Argument(..., exists=True, file_okay=False, help="Directory containing multiple skill folders to analyze."),
save: bool = typer.Option(True, "--save/--no-save", help="Save the result to relationships.json in the directory."),
model: str = typer.Option(DEFAULT_MODEL, "--model", "-m", help="LLM model to use."),
+ provider: str = typer.Option(None, "--provider", help=f"LLM provider ({', '.join(SUPPORTED_PROVIDERS)}). Auto-detected when omitted."),
):
"""
Analyze and map relationships (similar_to, belong_to, compose_with, depend_on) between local skills.
-
- This command scans all subdirectories in the target folder, reads their descriptions,
+
+ This command scans all subdirectories in the target folder, reads their descriptions,
and uses AI to build a knowledge graph of how the skills relate to each other.
"""
# 1. Validate Environment
- if not API_KEY:
- console.print("[bold red]Error:[/bold red] API_KEY environment variable is not set.")
+ cfg = resolve_provider_config(provider=provider, api_key=API_KEY, base_url=BASE_URL, model=model)
+ if not cfg["api_key"]:
+ console.print("[bold red]Error:[/bold red] API key is not set.")
+ console.print("Set API_KEY (OpenAI) or MINIMAX_API_KEY (MiniMax), or pass --provider.")
raise typer.Exit(code=1)
try:
# 2. Initialize Analyzer
analyzer = SkillRelationshipAnalyzer(
- api_key=API_KEY,
- base_url=BASE_URL,
- model=model
+ api_key=cfg["api_key"],
+ base_url=cfg["base_url"],
+ model=cfg["model"],
+ provider=provider,
)
# 3. Visual Feedback & Execution
diff --git a/skillnet-ai/src/skillnet_ai/client.py b/skillnet-ai/src/skillnet_ai/client.py
index 7637bb8..a2c5f77 100644
--- a/skillnet-ai/src/skillnet_ai/client.py
+++ b/skillnet-ai/src/skillnet_ai/client.py
@@ -7,6 +7,7 @@ from skillnet_ai.downloader import SkillDownloader, GitHubAPIError
from skillnet_ai.evaluator import SkillEvaluator, EvaluatorConfig
from skillnet_ai.searcher import SkillNetSearcher
from skillnet_ai.analyzer import SkillRelationshipAnalyzer
+from skillnet_ai.providers import resolve_provider_config
DEFAULT_MODEL = os.getenv("SKILLNET_MODEL", "gpt-4o")
@@ -17,27 +18,37 @@ class SkillNetError(Exception):
class SkillNetClient:
"""
A Python SDK client for interacting with SkillNet services.
-
+
This client aggregates Search, Download, Create, Evaluate, and Analyze functionalities.
"""
def __init__(
- self,
- api_key: Optional[str] = None,
+ self,
+ api_key: Optional[str] = None,
base_url: Optional[str] = None,
- github_token: Optional[str] = None
+ github_token: Optional[str] = None,
+ provider: Optional[str] = None,
):
"""
Initialize the SkillNet Client.
Args:
- api_key: OpenAI/SkillNet API Key. Defaults to env var API_KEY.
- base_url: Base URL for the LLM API. Defaults to env var BASE_URL or OpenAI default.
+ api_key: LLM API Key. Defaults to env var API_KEY (or MINIMAX_API_KEY for MiniMax).
+ base_url: Base URL for the LLM API. Defaults to env var BASE_URL or provider default.
github_token: GitHub token for downloading private skills or avoiding rate limits.
Defaults to env var GITHUB_TOKEN.
+ provider: LLM provider name (e.g. "openai", "minimax"). When set, the
+ provider's default base_url, model, and API key env var are used
+ unless explicitly overridden. Auto-detected from MINIMAX_API_KEY
+ when omitted.
"""
- self.api_key = api_key or os.getenv("API_KEY")
- self.base_url = base_url or os.getenv("BASE_URL")
+ cfg = resolve_provider_config(
+ provider=provider, api_key=api_key, base_url=base_url
+ )
+ self.api_key = cfg["api_key"]
+ self.base_url = cfg["base_url"]
+ self.provider = provider
+ self._provider_preset = cfg["preset"]
self.github_token = github_token or os.getenv("GITHUB_TOKEN")
@@ -194,9 +205,10 @@ class SkillNetClient:
try:
creator = SkillCreator(
- api_key=self.api_key,
- base_url=self.base_url,
- model=model
+ api_key=self.api_key,
+ base_url=self.base_url,
+ model=model,
+ provider=self.provider,
)
if input_type == "github":
@@ -269,7 +281,8 @@ class SkillNetClient:
model=model,
max_workers=max_workers,
cache_dir=cache_dir,
- github_token=self.github_token
+ github_token=self.github_token,
+ provider=self.provider,
)
evaluator = SkillEvaluator(config)
@@ -326,7 +339,8 @@ class SkillNetClient:
analyzer = SkillRelationshipAnalyzer(
api_key=self.api_key,
base_url=self.base_url,
- model=model
+ model=model,
+ provider=self.provider,
)
results = analyzer.analyze_local_skills(
diff --git a/skillnet-ai/src/skillnet_ai/creator.py b/skillnet-ai/src/skillnet_ai/creator.py
index 12b92b7..9d8e7db 100644
--- a/skillnet-ai/src/skillnet_ai/creator.py
+++ b/skillnet-ai/src/skillnet_ai/creator.py
@@ -19,6 +19,11 @@ from skillnet_ai.prompts import (
PROMPT_SKILL_SYSTEM_PROMPT,
PROMPT_SKILL_USER_PROMPT_TEMPLATE
)
+from skillnet_ai.providers import (
+ resolve_provider_config,
+ postprocess_response,
+ ProviderPreset,
+)
logger = logging.getLogger(__name__)
@@ -26,15 +31,25 @@ class SkillCreator:
"""
Creates Skill packages from execution trajectories using OpenAI-compatible LLMs.
"""
-
- def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None, model: str = "gpt-4o"):
- self.api_key = api_key or os.getenv("API_KEY")
- self.base_url = base_url or os.getenv("BASE_URL") or "https://api.openai.com/v1"
- self.model = model
-
+
+ def __init__(
+ self,
+ api_key: Optional[str] = None,
+ base_url: Optional[str] = None,
+ model: Optional[str] = None,
+ provider: Optional[str] = None,
+ ):
+ cfg = resolve_provider_config(
+ provider=provider, api_key=api_key, base_url=base_url, model=model
+ )
+ self.api_key = cfg["api_key"]
+ self.base_url = cfg["base_url"]
+ self.model = cfg["model"]
+ self._preset: Optional[ProviderPreset] = cfg["preset"]
+
if not self.api_key:
raise ValueError("API Key is missing. Please provide it in init or set API_KEY environment variable.")
-
+
self.client = OpenAI(api_key=self.api_key, base_url=self.base_url)
def _get_llm_response(self, messages: List[dict]) -> str:
@@ -44,7 +59,10 @@ class SkillCreator:
model=self.model,
messages=messages
)
- return response.choices[0].message.content
+ text = response.choices[0].message.content
+ if self._preset:
+ text = postprocess_response(text, self._preset)
+ return text
except Exception as e:
logger.error(f"LLM Call Failed: {e}")
raise
diff --git a/skillnet-ai/src/skillnet_ai/evaluator.py b/skillnet-ai/src/skillnet_ai/evaluator.py
index 5c08102..6864936 100644
--- a/skillnet-ai/src/skillnet_ai/evaluator.py
+++ b/skillnet-ai/src/skillnet_ai/evaluator.py
@@ -14,6 +14,12 @@ from tqdm import tqdm
from skillnet_ai.downloader import SkillDownloader
from skillnet_ai.prompts import SKILL_EVALUATION_PROMPT
+from skillnet_ai.providers import (
+ resolve_provider_config,
+ clamp_temperature,
+ postprocess_response,
+ ProviderPreset,
+)
logger = logging.getLogger(__name__)
@@ -38,6 +44,7 @@ class EvaluatorConfig:
include_script_results: bool = False
max_script_output_chars: int = 400
github_token: Optional[str] = None
+ provider: Optional[str] = None
@dataclass
@@ -704,12 +711,23 @@ class PromptBuilder:
class LLMClient:
"""Thin wrapper around the OpenAI client for evaluation calls."""
-
+
def __init__(self, config: EvaluatorConfig):
- self.client = OpenAI(api_key=config.api_key, base_url=config.base_url)
- self.model = config.model
- self.temperature = config.temperature
-
+ cfg = resolve_provider_config(
+ provider=config.provider,
+ api_key=config.api_key,
+ base_url=config.base_url,
+ model=config.model,
+ )
+ self.client = OpenAI(api_key=cfg["api_key"], base_url=cfg["base_url"])
+ self.model = cfg["model"]
+ self._preset: Optional[ProviderPreset] = cfg["preset"]
+
+ temperature = config.temperature
+ if self._preset:
+ temperature = clamp_temperature(temperature, self._preset)
+ self.temperature = temperature
+
def evaluate(self, prompt: str) -> Dict[str, Any]:
"""Call the LLM with the given prompt and parse JSON response."""
messages = [
@@ -723,7 +741,7 @@ class LLMClient:
},
{"role": "user", "content": prompt}
]
-
+
try:
response = self.client.chat.completions.create(
model=self.model,
@@ -732,6 +750,8 @@ class LLMClient:
temperature=self.temperature
)
raw_response = response.choices[0].message.content
+ if self._preset:
+ raw_response = postprocess_response(raw_response, self._preset)
return json.loads(raw_response)
except Exception as e:
logger.error(f"LLM call failed: {e}")
diff --git a/skillnet-ai/src/skillnet_ai/providers.py b/skillnet-ai/src/skillnet_ai/providers.py
new file mode 100644
index 0000000..0452bea
--- /dev/null
+++ b/skillnet-ai/src/skillnet_ai/providers.py
@@ -0,0 +1,163 @@
+"""
+LLM provider presets and utilities for SkillNet.
+
+Supports multiple LLM providers with auto-detection and provider-specific
+parameter handling (e.g., temperature clamping, response post-processing).
+"""
+
+import os
+import re
+from dataclasses import dataclass
+from typing import Optional, Dict, Any
+
+
+@dataclass(frozen=True)
+class ProviderPreset:
+ """Immutable configuration preset for an LLM provider."""
+ name: str
+ base_url: str
+ default_model: str
+ api_key_env: str
+ min_temperature: float = 0.0
+ max_temperature: float = 2.0
+ supports_json_mode: bool = True
+ strip_think_tags: bool = False
+
+
+# ---------------------------------------------------------------------------
+# Provider registry
+# ---------------------------------------------------------------------------
+
+PROVIDER_PRESETS: Dict[str, ProviderPreset] = {
+ "openai": ProviderPreset(
+ name="openai",
+ base_url="https://api.openai.com/v1",
+ default_model="gpt-4o",
+ api_key_env="API_KEY",
+ ),
+ "minimax": ProviderPreset(
+ name="minimax",
+ base_url="https://api.minimax.io/v1",
+ default_model="MiniMax-M2.7",
+ api_key_env="MINIMAX_API_KEY",
+ min_temperature=0.01,
+ max_temperature=1.0,
+ supports_json_mode=True,
+ strip_think_tags=True,
+ ),
+}
+
+SUPPORTED_PROVIDERS = list(PROVIDER_PRESETS.keys())
+
+
+def get_provider_preset(provider: str) -> ProviderPreset:
+ """Look up a provider preset by name (case-insensitive).
+
+ Raises ``ValueError`` if the provider is not recognised.
+ """
+ key = provider.lower()
+ if key not in PROVIDER_PRESETS:
+ raise ValueError(
+ f"Unknown provider '{provider}'. "
+ f"Supported providers: {', '.join(SUPPORTED_PROVIDERS)}"
+ )
+ return PROVIDER_PRESETS[key]
+
+
+# ---------------------------------------------------------------------------
+# Provider auto-detection
+# ---------------------------------------------------------------------------
+
+def detect_provider(
+ api_key: Optional[str] = None,
+ base_url: Optional[str] = None,
+) -> Optional[str]:
+ """Best-effort detection of the LLM provider from env / arguments.
+
+ Detection order:
+ 1. If *base_url* contains a known provider domain, use that.
+ 2. If ``MINIMAX_API_KEY`` is set (and no OpenAI key), default to minimax.
+ 3. Fall back to ``None`` (caller should use OpenAI defaults).
+ """
+ # 1. URL-based detection
+ if base_url:
+ url_lower = base_url.lower()
+ if "minimax" in url_lower:
+ return "minimax"
+ if "openai" in url_lower:
+ return "openai"
+
+ # 2. API-key-based detection
+ if not api_key and not os.getenv("API_KEY"):
+ if os.getenv("MINIMAX_API_KEY"):
+ return "minimax"
+
+ return None
+
+
+# ---------------------------------------------------------------------------
+# Provider-specific parameter helpers
+# ---------------------------------------------------------------------------
+
+def clamp_temperature(temperature: float, preset: ProviderPreset) -> float:
+ """Clamp *temperature* to the provider's accepted range."""
+ return max(preset.min_temperature, min(temperature, preset.max_temperature))
+
+
+_THINK_TAG_RE = re.compile(r"<think>.*?</think>\s*", re.DOTALL)
+
+
+def strip_think_tags(text: str) -> str:
+ """Remove ``<think>…</think>`` blocks that some models emit."""
+ return _THINK_TAG_RE.sub("", text).strip()
+
+
+def postprocess_response(text: str, preset: ProviderPreset) -> str:
+ """Apply provider-specific post-processing to a raw LLM response."""
+ if preset.strip_think_tags:
+ text = strip_think_tags(text)
+ return text
+
+
+# ---------------------------------------------------------------------------
+# Resolve helpers (used by client / creator / evaluator / analyzer)
+# ---------------------------------------------------------------------------
+
+def resolve_provider_config(
+ provider: Optional[str] = None,
+ api_key: Optional[str] = None,
+ base_url: Optional[str] = None,
+ model: Optional[str] = None,
+) -> Dict[str, Any]:
+ """Resolve the final ``(api_key, base_url, model, preset)`` tuple.
+
+ When *provider* is given explicitly the corresponding preset supplies
+ defaults. Otherwise the function falls back to auto-detection or plain
+ OpenAI defaults.
+
+ Returns a dict with keys ``api_key``, ``base_url``, ``model``, ``preset``.
+ """
+ # Determine provider
+ effective_provider = provider
+ if not effective_provider:
+ effective_provider = detect_provider(api_key=api_key, base_url=base_url)
+
+ preset: Optional[ProviderPreset] = None
+ if effective_provider:
+ preset = get_provider_preset(effective_provider)
+
+ if preset:
+ resolved_api_key = api_key or os.getenv(preset.api_key_env) or os.getenv("API_KEY")
+ resolved_base_url = base_url or os.getenv("BASE_URL") or preset.base_url
+ resolved_model = model or os.getenv("SKILLNET_MODEL") or preset.default_model
+ else:
+ resolved_api_key = api_key or os.getenv("API_KEY")
+ resolved_base_url = base_url or os.getenv("BASE_URL") or "https://api.openai.com/v1"
+ resolved_model = model or os.getenv("SKILLNET_MODEL") or "gpt-4o"
+
+ return {
+ "api_key": resolved_api_key,
+ "base_url": resolved_base_url,
+ "model": resolved_model,
+ "preset": preset,
+ }
diff --git a/skillnet-ai/tests/__init__.py b/skillnet-ai/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/skillnet-ai/tests/test_minimax_integration.py b/skillnet-ai/tests/test_minimax_integration.py
new file mode 100644
index 0000000..e7aa4ae
--- /dev/null
+++ b/skillnet-ai/tests/test_minimax_integration.py
@@ -0,0 +1,197 @@
+"""Integration tests for MiniMax provider with SkillNet components.
+
+These tests verify that the provider plumbing works end-to-end without
+actually calling external APIs — the OpenAI client is mocked.
+"""
+
+import json
+import os
+import unittest
+from unittest.mock import MagicMock, patch
+
+from skillnet_ai.client import SkillNetClient
+from skillnet_ai.creator import SkillCreator
+from skillnet_ai.evaluator import EvaluatorConfig, LLMClient
+from skillnet_ai.analyzer import SkillRelationshipAnalyzer
+from skillnet_ai.providers import PROVIDER_PRESETS
+
+
+def _mock_chat_response(content: str):
+ """Build a mock OpenAI ChatCompletion response."""
+ choice = MagicMock()
+ choice.message.content = content
+ response = MagicMock()
+ response.choices = [choice]
+ return response
+
+
+class TestSkillNetClientMiniMax(unittest.TestCase):
+ """SkillNetClient initialises correctly with provider='minimax'."""
+
+ @patch.dict(os.environ, {"MINIMAX_API_KEY": "test-mm-key"}, clear=True)
+ def test_minimax_provider_sets_defaults(self):
+ client = SkillNetClient(provider="minimax")
+ self.assertEqual(client.api_key, "test-mm-key")
+ self.assertEqual(client.base_url, "https://api.minimax.io/v1")
+ self.assertEqual(client.provider, "minimax")
+ self.assertIsNotNone(client._provider_preset)
+ self.assertEqual(client._provider_preset.name, "minimax")
+
+ @patch.dict(os.environ, {"MINIMAX_API_KEY": "auto-key"}, clear=True)
+ def test_auto_detect_minimax(self):
+ client = SkillNetClient()
+ self.assertEqual(client.api_key, "auto-key")
+ self.assertEqual(client.base_url, "https://api.minimax.io/v1")
+
+ @patch.dict(os.environ, {}, clear=True)
+ def test_explicit_key_overrides_env(self):
+ client = SkillNetClient(
+ provider="minimax", api_key="explicit-key"
+ )
+ self.assertEqual(client.api_key, "explicit-key")
+
+
+class TestSkillCreatorMiniMax(unittest.TestCase):
+ """SkillCreator handles MiniMax think-tag stripping."""
+
+ @patch("skillnet_ai.creator.OpenAI")
+ @patch.dict(os.environ, {}, clear=True)
+ def test_think_tag_stripped_from_response(self, MockOpenAI):
+ mock_client = MagicMock()
+ MockOpenAI.return_value = mock_client
+
+ raw = '<think>Let me reason about this...</think>[{"name": "test_skill", "description": "A test"}]'
+ mock_client.chat.completions.create.return_value = _mock_chat_response(raw)
+
+ creator = SkillCreator(
+ api_key="test-key", provider="minimax"
+ )
+ result = creator._get_llm_response([{"role": "user", "content": "test"}])
+ self.assertNotIn("<think>", result)
+ self.assertIn("test_skill", result)
+
+ @patch("skillnet_ai.creator.OpenAI")
+ @patch.dict(os.environ, {}, clear=True)
+ def test_minimax_base_url_used(self, MockOpenAI):
+ SkillCreator(api_key="test-key", provider="minimax")
+ MockOpenAI.assert_called_once_with(
+ api_key="test-key",
+ base_url="https://api.minimax.io/v1",
+ )
+
+ @patch("skillnet_ai.creator.OpenAI")
+ @patch.dict(os.environ, {}, clear=True)
+ def test_minimax_default_model(self, MockOpenAI):
+ mock_client = MagicMock()
+ MockOpenAI.return_value = mock_client
+ mock_client.chat.completions.create.return_value = _mock_chat_response("test")
+
+ creator = SkillCreator(api_key="test-key", provider="minimax")
+ self.assertEqual(creator.model, "MiniMax-M2.7")
+
+
+class TestLLMClientMiniMax(unittest.TestCase):
+ """LLMClient (evaluator) handles MiniMax temperature and think-tags."""
+
+ @patch("skillnet_ai.evaluator.OpenAI")
+ @patch.dict(os.environ, {}, clear=True)
+ def test_temperature_clamped(self, MockOpenAI):
+ mock_client = MagicMock()
+ MockOpenAI.return_value = mock_client
+
+ config = EvaluatorConfig(
+ api_key="test-key",
+ base_url="https://api.minimax.io/v1",
+ model="MiniMax-M2.7",
+ temperature=0.0,
+ provider="minimax",
+ )
+ llm_client = LLMClient(config)
+ # Temperature 0.0 should be clamped to min (0.01)
+ minimax_preset = PROVIDER_PRESETS["minimax"]
+ self.assertEqual(llm_client.temperature, minimax_preset.min_temperature)
+
+ @patch("skillnet_ai.evaluator.OpenAI")
+ @patch.dict(os.environ, {}, clear=True)
+ def test_think_tags_stripped_from_json(self, MockOpenAI):
+ mock_client = MagicMock()
+ MockOpenAI.return_value = mock_client
+
+ raw_json = '<think>analyzing...</think>{"safety": {"level": "Good", "reason": "Safe"}}'
+ mock_client.chat.completions.create.return_value = _mock_chat_response(raw_json)
+
+ config = EvaluatorConfig(
+ api_key="test-key",
+ base_url="https://api.minimax.io/v1",
+ model="MiniMax-M2.7",
+ provider="minimax",
+ )
+ llm_client = LLMClient(config)
+ result = llm_client.evaluate("test prompt")
+ self.assertEqual(result["safety"]["level"], "Good")
+
+ @patch("skillnet_ai.evaluator.OpenAI")
+ @patch.dict(os.environ, {}, clear=True)
+ def test_temperature_within_range_unchanged(self, MockOpenAI):
+ MockOpenAI.return_value = MagicMock()
+
+ config = EvaluatorConfig(
+ api_key="test-key",
+ base_url="https://api.minimax.io/v1",
+ model="MiniMax-M2.7",
+ temperature=0.5,
+ provider="minimax",
+ )
+ llm_client = LLMClient(config)
+ self.assertEqual(llm_client.temperature, 0.5)
+
+
+class TestAnalyzerMiniMax(unittest.TestCase):
+ """SkillRelationshipAnalyzer works with MiniMax provider."""
+
+ @patch("skillnet_ai.analyzer.OpenAI")
+ @patch.dict(os.environ, {}, clear=True)
+ def test_minimax_provider_initialises(self, MockOpenAI):
+ MockOpenAI.return_value = MagicMock()
+
+ analyzer = SkillRelationshipAnalyzer(
+ api_key="test-key", provider="minimax"
+ )
+ self.assertEqual(analyzer.model, "MiniMax-M2.7")
+ self.assertEqual(analyzer.base_url, "https://api.minimax.io/v1")
+ MockOpenAI.assert_called_once_with(
+ api_key="test-key",
+ base_url="https://api.minimax.io/v1",
+ )
+
+ @patch("skillnet_ai.analyzer.OpenAI")
+ @patch.dict(os.environ, {}, clear=True)
+ def test_think_tags_stripped_from_analysis(self, MockOpenAI):
+ mock_client = MagicMock()
+ MockOpenAI.return_value = mock_client
+
+ raw = (
+ '<think>reasoning about relationships</think>'
+ '<Skill_Relationships>'
+ '[{"source": "A", "target": "B", "type": "similar_to", "reason": "both do X"}]'
+ '</Skill_Relationships>'
+ )
+ mock_client.chat.completions.create.return_value = _mock_chat_response(raw)
+
+ analyzer = SkillRelationshipAnalyzer(
+ api_key="test-key", provider="minimax"
+ )
+ # Mock internal methods to avoid filesystem access
+ analyzer._load_skills_metadata = MagicMock(return_value=[
+ {"name": "A", "description": "Skill A"},
+ {"name": "B", "description": "Skill B"},
+ ])
+ with patch("os.path.exists", return_value=True):
+ results = analyzer.analyze_local_skills("/fake/dir", save_to_file=False)
+ self.assertEqual(len(results), 1)
+ self.assertEqual(results[0]["source"], "A")
+ self.assertEqual(results[0]["type"], "similar_to")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/skillnet-ai/tests/test_providers.py b/skillnet-ai/tests/test_providers.py
new file mode 100644
index 0000000..0604e2c
--- /dev/null
+++ b/skillnet-ai/tests/test_providers.py
@@ -0,0 +1,265 @@
+"""Unit tests for the providers module."""
+
+import os
+import unittest
+from unittest.mock import patch
+
+from skillnet_ai.providers import (
+ PROVIDER_PRESETS,
+ SUPPORTED_PROVIDERS,
+ ProviderPreset,
+ get_provider_preset,
+ detect_provider,
+ clamp_temperature,
+ strip_think_tags,
+ postprocess_response,
+ resolve_provider_config,
+)
+
+
+class TestProviderPresets(unittest.TestCase):
+ """Verify that built-in provider presets are complete and consistent."""
+
+ def test_openai_preset_exists(self):
+ preset = PROVIDER_PRESETS["openai"]
+ self.assertEqual(preset.name, "openai")
+ self.assertEqual(preset.base_url, "https://api.openai.com/v1")
+ self.assertEqual(preset.default_model, "gpt-4o")
+ self.assertEqual(preset.api_key_env, "API_KEY")
+
+ def test_minimax_preset_exists(self):
+ preset = PROVIDER_PRESETS["minimax"]
+ self.assertEqual(preset.name, "minimax")
+ self.assertEqual(preset.base_url, "https://api.minimax.io/v1")
+ self.assertEqual(preset.default_model, "MiniMax-M2.7")
+ self.assertEqual(preset.api_key_env, "MINIMAX_API_KEY")
+
+ def test_minimax_temperature_range(self):
+ preset = PROVIDER_PRESETS["minimax"]
+ self.assertGreater(preset.min_temperature, 0.0)
+ self.assertLessEqual(preset.max_temperature, 1.0)
+
+ def test_minimax_strip_think_tags_enabled(self):
+ preset = PROVIDER_PRESETS["minimax"]
+ self.assertTrue(preset.strip_think_tags)
+
+ def test_openai_strip_think_tags_disabled(self):
+ preset = PROVIDER_PRESETS["openai"]
+ self.assertFalse(preset.strip_think_tags)
+
+ def test_supported_providers_list(self):
+ self.assertIn("openai", SUPPORTED_PROVIDERS)
+ self.assertIn("minimax", SUPPORTED_PROVIDERS)
+
+ def test_preset_is_frozen(self):
+ preset = PROVIDER_PRESETS["minimax"]
+ with self.assertRaises(AttributeError):
+ preset.name = "changed"
+
+
+class TestGetProviderPreset(unittest.TestCase):
+ """Tests for get_provider_preset()."""
+
+ def test_valid_provider(self):
+ preset = get_provider_preset("minimax")
+ self.assertIsInstance(preset, ProviderPreset)
+ self.assertEqual(preset.name, "minimax")
+
+ def test_case_insensitive(self):
+ preset = get_provider_preset("MiniMax")
+ self.assertEqual(preset.name, "minimax")
+
+ def test_unknown_provider_raises(self):
+ with self.assertRaises(ValueError) as ctx:
+ get_provider_preset("unknown_provider")
+ self.assertIn("Unknown provider", str(ctx.exception))
+
+ def test_openai_preset(self):
+ preset = get_provider_preset("openai")
+ self.assertEqual(preset.name, "openai")
+
+
+class TestDetectProvider(unittest.TestCase):
+ """Tests for detect_provider()."""
+
+ def test_url_based_minimax(self):
+ result = detect_provider(base_url="https://api.minimax.io/v1")
+ self.assertEqual(result, "minimax")
+
+ def test_url_based_openai(self):
+ result = detect_provider(base_url="https://api.openai.com/v1")
+ self.assertEqual(result, "openai")
+
+ @patch.dict(os.environ, {"MINIMAX_API_KEY": "test-key"}, clear=False)
+ def test_env_based_minimax(self):
+ # Clear API_KEY to trigger MINIMAX_API_KEY detection
+ with patch.dict(os.environ, {}, clear=False):
+ os.environ.pop("API_KEY", None)
+ result = detect_provider()
+ self.assertEqual(result, "minimax")
+
+ def test_no_detection_returns_none(self):
+ with patch.dict(os.environ, {}, clear=True):
+ result = detect_provider()
+ self.assertIsNone(result)
+
+ def test_url_takes_precedence(self):
+ result = detect_provider(
+ base_url="https://api.minimax.io/v1",
+ api_key="sk-something",
+ )
+ self.assertEqual(result, "minimax")
+
+
+class TestClampTemperature(unittest.TestCase):
+ """Tests for clamp_temperature()."""
+
+ def setUp(self):
+ self.minimax = PROVIDER_PRESETS["minimax"]
+ self.openai = PROVIDER_PRESETS["openai"]
+
+ def test_minimax_clamp_zero(self):
+ result = clamp_temperature(0.0, self.minimax)
+ self.assertEqual(result, self.minimax.min_temperature)
+
+ def test_minimax_clamp_high(self):
+ result = clamp_temperature(2.0, self.minimax)
+ self.assertEqual(result, 1.0)
+
+ def test_minimax_passthrough(self):
+ result = clamp_temperature(0.5, self.minimax)
+ self.assertEqual(result, 0.5)
+
+ def test_openai_no_clamp(self):
+ result = clamp_temperature(1.5, self.openai)
+ self.assertEqual(result, 1.5)
+
+ def test_negative_clamped_to_min(self):
+ result = clamp_temperature(-1.0, self.minimax)
+ self.assertEqual(result, self.minimax.min_temperature)
+
+
+class TestStripThinkTags(unittest.TestCase):
+ """Tests for strip_think_tags()."""
+
+ def test_removes_single_think_block(self):
+ text = "<think>internal reasoning</think>Hello world"
+ result = strip_think_tags(text)
+ self.assertEqual(result, "Hello world")
+
+ def test_removes_multiline_think_block(self):
+ text = "<think>\nline1\nline2\n</think>\nAnswer: 42"
+ result = strip_think_tags(text)
+ self.assertEqual(result, "Answer: 42")
+
+ def test_removes_multiple_think_blocks(self):
+ text = "<think>a</think>foo<think>b</think>bar"
+ result = strip_think_tags(text)
+ self.assertEqual(result, "foobar")
+
+ def test_no_think_tags_passthrough(self):
+ text = "Just plain text"
+ result = strip_think_tags(text)
+ self.assertEqual(result, "Just plain text")
+
+ def test_empty_string(self):
+ result = strip_think_tags("")
+ self.assertEqual(result, "")
+
+ def test_think_tag_with_json_content(self):
+ text = '<think>Let me analyze...</think>{"safety": {"level": "Good"}}'
+ result = strip_think_tags(text)
+ self.assertEqual(result, '{"safety": {"level": "Good"}}')
+
+
+class TestPostprocessResponse(unittest.TestCase):
+ """Tests for postprocess_response()."""
+
+ def test_minimax_strips_think_tags(self):
+ preset = PROVIDER_PRESETS["minimax"]
+ text = "<think>reasoning</think>answer"
+ result = postprocess_response(text, preset)
+ self.assertEqual(result, "answer")
+
+ def test_openai_no_stripping(self):
+ preset = PROVIDER_PRESETS["openai"]
+ text = "<think>reasoning</think>answer"
+ result = postprocess_response(text, preset)
+ self.assertEqual(result, "<think>reasoning</think>answer")
+
+
+class TestResolveProviderConfig(unittest.TestCase):
+ """Tests for resolve_provider_config()."""
+
+ @patch.dict(os.environ, {}, clear=True)
+ def test_explicit_minimax_provider(self):
+ cfg = resolve_provider_config(
+ provider="minimax", api_key="test-key"
+ )
+ self.assertEqual(cfg["api_key"], "test-key")
+ self.assertEqual(cfg["base_url"], "https://api.minimax.io/v1")
+ self.assertEqual(cfg["model"], "MiniMax-M2.7")
+ self.assertIsNotNone(cfg["preset"])
+ self.assertEqual(cfg["preset"].name, "minimax")
+
+ @patch.dict(os.environ, {}, clear=True)
+ def test_explicit_openai_provider(self):
+ cfg = resolve_provider_config(
+ provider="openai", api_key="sk-test"
+ )
+ self.assertEqual(cfg["base_url"], "https://api.openai.com/v1")
+ self.assertEqual(cfg["model"], "gpt-4o")
+
+ @patch.dict(os.environ, {"MINIMAX_API_KEY": "mm-key"}, clear=True)
+ def test_auto_detect_minimax_from_env(self):
+ cfg = resolve_provider_config()
+ self.assertEqual(cfg["api_key"], "mm-key")
+ self.assertEqual(cfg["base_url"], "https://api.minimax.io/v1")
+ self.assertEqual(cfg["model"], "MiniMax-M2.7")
+
+ @patch.dict(os.environ, {}, clear=True)
+ def test_explicit_values_override_preset(self):
+ cfg = resolve_provider_config(
+ provider="minimax",
+ api_key="custom-key",
+ base_url="https://custom.example.com/v1",
+ model="custom-model",
+ )
+ self.assertEqual(cfg["api_key"], "custom-key")
+ self.assertEqual(cfg["base_url"], "https://custom.example.com/v1")
+ self.assertEqual(cfg["model"], "custom-model")
+ self.assertIsNotNone(cfg["preset"])
+
+ @patch.dict(os.environ, {}, clear=True)
+ def test_no_provider_falls_back_to_openai_defaults(self):
+ cfg = resolve_provider_config(api_key="sk-test")
+ self.assertEqual(cfg["base_url"], "https://api.openai.com/v1")
+ self.assertEqual(cfg["model"], "gpt-4o")
+ self.assertIsNone(cfg["preset"])
+
+ @patch.dict(os.environ, {"SKILLNET_MODEL": "custom-env-model"}, clear=False)
+ def test_env_model_override(self):
+ with patch.dict(os.environ, {}, clear=False):
+ cfg = resolve_provider_config(provider="minimax", api_key="test")
+ self.assertEqual(cfg["model"], "custom-env-model")
+
+ @patch.dict(os.environ, {"API_KEY": "from-env"}, clear=True)
+ def test_minimax_falls_back_to_api_key_env(self):
+ cfg = resolve_provider_config(provider="minimax")
+ self.assertEqual(cfg["api_key"], "from-env")
+
+
+class TestProviderPresetMiniMaxModels(unittest.TestCase):
+ """Verify MiniMax model defaults."""
+
+ def test_default_model_is_m27(self):
+ preset = PROVIDER_PRESETS["minimax"]
+ self.assertEqual(preset.default_model, "MiniMax-M2.7")
+
+ def test_json_mode_supported(self):
+ preset = PROVIDER_PRESETS["minimax"]
+ self.assertTrue(preset.supports_json_mode)
+
+
+if __name__ == "__main__":
+ unittest.main()