Create, Evaluate, and Connect AI Skills
Python ai-agentsai-skillsartificial-intelligenceknowledge-graphlarge-language-modelsnatural-language-processingopenkgskillnetskills
feat: add MiniMax as first-class LLM provider
PR Botfc363763e70d
diff --git a/README.md b/README.mdindex 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 Discoverydiff --git a/skillnet-ai/src/skillnet_ai/__init__.py b/skillnet-ai/src/skillnet_ai/__init__.pyindex 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 SkillDownloaderfrom skillnet_ai.evaluator import SkillEvaluator, EvaluatorConfigfrom skillnet_ai.searcher import SkillNetSearcherfrom 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 filediff --git a/skillnet-ai/src/skillnet_ai/analyzer.py b/skillnet-ai/src/skillnet_ai/analyzer.pyindex 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 tagsjson_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.pyindex 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, GitHubAPIErrorfrom skillnet_ai.evaluator import SkillEvaluator, EvaluatorConfigfrom skillnet_ai.searcher import SkillNetSearcherfrom skillnet_ai.analyzer import SkillRelationshipAnalyzer+from skillnet_ai.providers import resolve_provider_config, SUPPORTED_PROVIDERSapp = typer.Typer(help="SkillNet AI CLI Tool")console = Console()@@ -183,10 +184,11 @@ def create(# Model optionsmodel: 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 handlerif 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 Creatorcreator = 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 Resultsif 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_filescreator = 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 Resultsif 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_filesfor 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_filesraise 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 Resultsif 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 optionsmodel: 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 Evaluatorconfig = 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 Analyzeranalyzer = 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 & Executiondiff --git a/skillnet-ai/src/skillnet_ai/client.py b/skillnet-ai/src/skillnet_ai/client.pyindex 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, GitHubAPIErrorfrom skillnet_ai.evaluator import SkillEvaluator, EvaluatorConfigfrom skillnet_ai.searcher import SkillNetSearcherfrom skillnet_ai.analyzer import SkillRelationshipAnalyzer+from skillnet_ai.providers import resolve_provider_configDEFAULT_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.pyindex 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 textexcept Exception as e:logger.error(f"LLM Call Failed: {e}")raisediff --git a/skillnet-ai/src/skillnet_ai/evaluator.py b/skillnet-ai/src/skillnet_ai/evaluator.pyindex 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 tqdmfrom skillnet_ai.downloader import SkillDownloaderfrom 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 = Falsemax_script_output_chars: int = 400github_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.pynew file mode 100644index 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__.pynew file mode 100644index 0000000..e69de29diff --git a/skillnet-ai/tests/test_minimax_integration.py b/skillnet-ai/tests/test_minimax_integration.pynew file mode 100644index 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.pynew file mode 100644index 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()