fusefable 0.1.0__tar.gz → 0.1.2__tar.gz

fusefable-0.1.2/PKG-INFO

@@ -0,0 +1,221 @@
+Metadata-Version: 2.4
+Name: fusefable
+Version: 0.1.2
+Summary: Fuse multiple AI models and judge the best answer for coding
+Author: proultrax9
+License: MIT
+Project-URL: Homepage, https://github.com/proultrax9/fusefable
+Project-URL: Repository, https://github.com/proultrax9/fusefable
+Keywords: llm,ai,openrouter,cli,mcp,fusion,coding
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27
+Requires-Dist: typer>=0.12
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: respx>=0.21; extra == "dev"
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.2; extra == "mcp"
+Dynamic: license-file
+
+# Fuse Fable
+
+🌐 **Languages:** English · [ไทย (Thai)](https://github.com/proultrax9/fusefable/blob/main/README.th.md)
+
+Fan out a coding prompt to many AI models **in parallel**, then let a judge pick the
+single best answer — total latency ≈ **x2** (slowest model + one judge pass), not x7–x15.
+
+Works three ways: as a **CLI**, as an **MCP server** (connect Cursor / VS Code / Claude),
+and as a **subagent / pipe** (callable by other tools and scripts).
+
+## Install
+```bash
+pip install fusefable            # core
+pip install "fusefable[mcp]"     # if you want the MCP server
+```
+From source:
+```bash
+git clone https://github.com/proultrax9/fusefable.git
+cd fusefable
+pip install -e ".[mcp]"
+```
+
+## Setup (first run)
+```bash
+fusefable config
+```
+- Choose **AI Gateway** → one key for everything, then it asks "how many models?" and
+  prompts for each one.
+  - Known gateways (base URL auto-filled): `openrouter`, `groq`, `together`,
+    `fireworks`, `deepinfra`, `novita`, `hyperbolic`, `aimlapi`, `portkey`,
+    `deepseek`, `openai` — any other works too, just type its base URL.
+- Or **Single providers** → it asks how many, then the **API kind** of each:
+  - `openai_compat` — any OpenAI-compatible endpoint (you provide the base URL)
+  - `anthropic` — Anthropic native (`/v1/messages`, base URL auto-filled)
+  - `google` — Google Gemini native (`generateContent`, base URL auto-filled)
+
+Set your API key as an environment variable named as the wizard asks:
+```bash
+export OPENROUTER_API_KEY=sk-...      # macOS/Linux
+setx OPENROUTER_API_KEY "sk-..."      # Windows (open a new terminal afterwards)
+```
+
+Config is stored at `~/.fusefable/config.yaml`.
+
+## 1) Use as a CLI
+```bash
+fusefable ask "Write a quicksort function in Python"
+fusefable ask --show-all "..."                   # show every answer + judge reason
+fusefable ask --models gpt-5,qwen3-coder "..."   # restrict to specific models
+fusefable ask --cheap "..."                      # use cheap_models from config
+ff ask "..."                                      # short alias
+```
+
+## 2) Use as a subagent / in a pipe
+```bash
+fusefable ask --quiet "..."                # print only the answer (no headers)
+echo "Explain this code" | fusefable ask --quiet   # read the prompt from stdin
+cat bug.py | fusefable ask -q "Find the bug in this code"
+fusefable ask --json "..."                 # JSON output: answer, chosen_model, reason, cost, candidates
+```
+`--json` is ideal for scripts/agents that parse the result; `--quiet` is ideal for piping.
+
+## 3) Use as an MCP server (Cursor / VS Code / Claude / other agents)
+Run as an MCP server over stdio:
+```bash
+fusefable mcp
+```
+Exposes a tool `fuse_ask(question, models?, cheap?)` for any MCP client.
+
+### Cursor
+`~/.cursor/mcp.json` (or Settings → MCP):
+```json
+{
+  "mcpServers": {
+    "fusefable": {
+      "command": "fusefable",
+      "args": ["mcp"],
+      "env": { "OPENROUTER_API_KEY": "sk-..." }
+    }
+  }
+}
+```
+
+### VS Code (Copilot / MCP-compatible extension)
+`.vscode/mcp.json` in your project:
+```json
+{
+  "servers": {
+    "fusefable": {
+      "command": "fusefable",
+      "args": ["mcp"],
+      "env": { "OPENROUTER_API_KEY": "sk-..." }
+    }
+  }
+}
+```
+
+### Claude Desktop
+`claude_desktop_config.json`:
+```json
+{
+  "mcpServers": {
+    "fusefable": {
+      "command": "fusefable",
+      "args": ["mcp"],
+      "env": { "OPENROUTER_API_KEY": "sk-..." }
+    }
+  }
+}
+```
+
+> Requires `pip install "fusefable[mcp]"` and a completed `fusefable config`.
+> If `fusefable` isn't on the app's PATH, use a full path such as `python -m fusefable.cli`.
+
+## Architecture
+
+```
+              ENTRYPOINTS (one shared core)
+   ┌─────────────┬──────────────────┬─────────────────────┐
+   │  CLI        │  pipe / subagent │  MCP server         │
+   │ fusefable   │ stdin · --quiet  │ fusefable mcp       │
+   │   ask "..." │      · --json    │ tool: fuse_ask()    │
+   └──────┬──────┴────────┬─────────┴──────────┬──────────┘
+          └───────────────┴────────────────────┘
+                          │
+                          ▼
+                ┌───────────────────┐      ~/.fusefable/config.yaml
+                │   core.fuse()     │◀──── (gateway | single providers,
+                └─────────┬─────────┘        models, judge, timeout)
+                          │
+                          ▼
+                ┌───────────────────┐
+                │  routing          │  build (provider, model) routes
+                │  + provider       │  via factory → pick adapter by kind
+                │    factory        │
+                └─────────┬─────────┘
+                          ▼
+        ┌──────────────  FAN-OUT (asyncio.gather)  ──────────────┐
+        │   ทุกตัวยิงพร้อมกัน · per-model timeout · ตัวพัง = ตัดทิ้ง       │
+        │                                                         │
+        ▼            ▼              ▼                ▼            ▼
+   ┌─────────┐ ┌──────────┐  ┌────────────┐   ┌──────────┐  ┌────────┐
+   │ openai_ │ │ anthropic│  │  google    │   │ openai_  │  │  ...   │
+   │ compat  │ │ native   │  │  native    │   │ compat   │  │        │
+   │(gateway)│ │/v1/msgs  │  │generateCont│   │          │  │        │
+   └────┬────┘ └────┬─────┘  └─────┬──────┘   └────┬─────┘  └───┬────┘
+        └───────────┴──────────────┴───────────────┴───────────┘
+                          │  Completion[] (สำเร็จเท่านั้น)
+                          ▼
+                ┌───────────────────┐
+                │  judge            │  ปกปิดชื่อ → Answer A/B/C...
+                │  (anonymized)     │  ให้ judge model เลือกตัวดีสุด
+                └─────────┬─────────┘  (พัง → fallback ตัวแรก)
+                          ▼
+                ┌───────────────────┐
+                │  FinalAnswer      │  text · chosen_model · reason
+                │  (+ cost estimate)│  · cost_usd · candidates
+                └───────────────────┘
+```
+
+**Request lifecycle**
+1. **Entrypoint** — CLI, a pipe/subagent call, or the MCP tool `fuse_ask()` — all funnel into one core function `core.fuse()`.
+2. **Routing** — config (gateway or single providers) is turned into `(provider, model)` routes; a provider **factory** picks the right adapter per `kind` (`openai_compat` / `anthropic` / `google`).
+3. **Fan-out** — every model is called concurrently via `asyncio.gather` (total time = slowest model). Each call has its own timeout; any model that times out or errors is dropped and never slows the run.
+4. **Judge** — model names are anonymized (Answer A/B/C...) so the judge picks on quality alone, not by brand; if the judge fails it falls back to the first answer.
+5. **Result** — returns the best answer with the chosen model, the judge's reason, an estimated cost, and all candidates.
+
+**Components** (`fusefable/`)
+
+| File | Responsibility |
+|---|---|
+| `cli.py` | Typer CLI (`ask` / `config` / `mcp`), output modes |
+| `mcp_server.py` | MCP server exposing the `fuse_ask` tool |
+| `core.py` | shared `fuse()` entrypoint + model selection |
+| `config.py` | load/save `config.yaml` |
+| `wizard.py` | interactive setup (gateway vs single, API kind) |
+| `routing.py` | config → `(provider, model)` routes |
+| `providers/factory.py` | pick adapter by `kind` |
+| `providers/openai_compat.py` · `anthropic.py` · `google.py` | provider adapters |
+| `fanout.py` | parallel fan-out (drops failures) |
+| `judge.py` | anonymized judging |
+| `fusion.py` | orchestrator: fan-out → judge → `FinalAnswer` |
+| `cost.py` | token-based cost estimate |
+| `models.py` | dataclasses: `Completion`, `FinalAnswer`, `ProviderConfig` |
+
+## Development
+```bash
+pip install -e ".[dev,mcp]"
+pytest -q
+```
+
+## License
+MIT

fusefable-0.1.2/README.md

@@ -0,0 +1,193 @@
+# Fuse Fable
+
+🌐 **Languages:** English · [ไทย (Thai)](https://github.com/proultrax9/fusefable/blob/main/README.th.md)
+
+Fan out a coding prompt to many AI models **in parallel**, then let a judge pick the
+single best answer — total latency ≈ **x2** (slowest model + one judge pass), not x7–x15.
+
+Works three ways: as a **CLI**, as an **MCP server** (connect Cursor / VS Code / Claude),
+and as a **subagent / pipe** (callable by other tools and scripts).
+
+## Install
+```bash
+pip install fusefable            # core
+pip install "fusefable[mcp]"     # if you want the MCP server
+```
+From source:
+```bash
+git clone https://github.com/proultrax9/fusefable.git
+cd fusefable
+pip install -e ".[mcp]"
+```
+
+## Setup (first run)
+```bash
+fusefable config
+```
+- Choose **AI Gateway** → one key for everything, then it asks "how many models?" and
+  prompts for each one.
+  - Known gateways (base URL auto-filled): `openrouter`, `groq`, `together`,
+    `fireworks`, `deepinfra`, `novita`, `hyperbolic`, `aimlapi`, `portkey`,
+    `deepseek`, `openai` — any other works too, just type its base URL.
+- Or **Single providers** → it asks how many, then the **API kind** of each:
+  - `openai_compat` — any OpenAI-compatible endpoint (you provide the base URL)
+  - `anthropic` — Anthropic native (`/v1/messages`, base URL auto-filled)
+  - `google` — Google Gemini native (`generateContent`, base URL auto-filled)
+
+Set your API key as an environment variable named as the wizard asks:
+```bash
+export OPENROUTER_API_KEY=sk-...      # macOS/Linux
+setx OPENROUTER_API_KEY "sk-..."      # Windows (open a new terminal afterwards)
+```
+
+Config is stored at `~/.fusefable/config.yaml`.
+
+## 1) Use as a CLI
+```bash
+fusefable ask "Write a quicksort function in Python"
+fusefable ask --show-all "..."                   # show every answer + judge reason
+fusefable ask --models gpt-5,qwen3-coder "..."   # restrict to specific models
+fusefable ask --cheap "..."                      # use cheap_models from config
+ff ask "..."                                      # short alias
+```
+
+## 2) Use as a subagent / in a pipe
+```bash
+fusefable ask --quiet "..."                # print only the answer (no headers)
+echo "Explain this code" | fusefable ask --quiet   # read the prompt from stdin
+cat bug.py | fusefable ask -q "Find the bug in this code"
+fusefable ask --json "..."                 # JSON output: answer, chosen_model, reason, cost, candidates
+```
+`--json` is ideal for scripts/agents that parse the result; `--quiet` is ideal for piping.
+
+## 3) Use as an MCP server (Cursor / VS Code / Claude / other agents)
+Run as an MCP server over stdio:
+```bash
+fusefable mcp
+```
+Exposes a tool `fuse_ask(question, models?, cheap?)` for any MCP client.
+
+### Cursor
+`~/.cursor/mcp.json` (or Settings → MCP):
+```json
+{
+  "mcpServers": {
+    "fusefable": {
+      "command": "fusefable",
+      "args": ["mcp"],
+      "env": { "OPENROUTER_API_KEY": "sk-..." }
+    }
+  }
+}
+```
+
+### VS Code (Copilot / MCP-compatible extension)
+`.vscode/mcp.json` in your project:
+```json
+{
+  "servers": {
+    "fusefable": {
+      "command": "fusefable",
+      "args": ["mcp"],
+      "env": { "OPENROUTER_API_KEY": "sk-..." }
+    }
+  }
+}
+```
+
+### Claude Desktop
+`claude_desktop_config.json`:
+```json
+{
+  "mcpServers": {
+    "fusefable": {
+      "command": "fusefable",
+      "args": ["mcp"],
+      "env": { "OPENROUTER_API_KEY": "sk-..." }
+    }
+  }
+}
+```
+
+> Requires `pip install "fusefable[mcp]"` and a completed `fusefable config`.
+> If `fusefable` isn't on the app's PATH, use a full path such as `python -m fusefable.cli`.
+
+## Architecture
+
+```
+              ENTRYPOINTS (one shared core)
+   ┌─────────────┬──────────────────┬─────────────────────┐
+   │  CLI        │  pipe / subagent │  MCP server         │
+   │ fusefable   │ stdin · --quiet  │ fusefable mcp       │
+   │   ask "..." │      · --json    │ tool: fuse_ask()    │
+   └──────┬──────┴────────┬─────────┴──────────┬──────────┘
+          └───────────────┴────────────────────┘
+                          │
+                          ▼
+                ┌───────────────────┐      ~/.fusefable/config.yaml
+                │   core.fuse()     │◀──── (gateway | single providers,
+                └─────────┬─────────┘        models, judge, timeout)
+                          │
+                          ▼
+                ┌───────────────────┐
+                │  routing          │  build (provider, model) routes
+                │  + provider       │  via factory → pick adapter by kind
+                │    factory        │
+                └─────────┬─────────┘
+                          ▼
+        ┌──────────────  FAN-OUT (asyncio.gather)  ──────────────┐
+        │   ทุกตัวยิงพร้อมกัน · per-model timeout · ตัวพัง = ตัดทิ้ง       │
+        │                                                         │
+        ▼            ▼              ▼                ▼            ▼
+   ┌─────────┐ ┌──────────┐  ┌────────────┐   ┌──────────┐  ┌────────┐
+   │ openai_ │ │ anthropic│  │  google    │   │ openai_  │  │  ...   │
+   │ compat  │ │ native   │  │  native    │   │ compat   │  │        │
+   │(gateway)│ │/v1/msgs  │  │generateCont│   │          │  │        │
+   └────┬────┘ └────┬─────┘  └─────┬──────┘   └────┬─────┘  └───┬────┘
+        └───────────┴──────────────┴───────────────┴───────────┘
+                          │  Completion[] (สำเร็จเท่านั้น)
+                          ▼
+                ┌───────────────────┐
+                │  judge            │  ปกปิดชื่อ → Answer A/B/C...
+                │  (anonymized)     │  ให้ judge model เลือกตัวดีสุด
+                └─────────┬─────────┘  (พัง → fallback ตัวแรก)
+                          ▼
+                ┌───────────────────┐
+                │  FinalAnswer      │  text · chosen_model · reason
+                │  (+ cost estimate)│  · cost_usd · candidates
+                └───────────────────┘
+```
+
+**Request lifecycle**
+1. **Entrypoint** — CLI, a pipe/subagent call, or the MCP tool `fuse_ask()` — all funnel into one core function `core.fuse()`.
+2. **Routing** — config (gateway or single providers) is turned into `(provider, model)` routes; a provider **factory** picks the right adapter per `kind` (`openai_compat` / `anthropic` / `google`).
+3. **Fan-out** — every model is called concurrently via `asyncio.gather` (total time = slowest model). Each call has its own timeout; any model that times out or errors is dropped and never slows the run.
+4. **Judge** — model names are anonymized (Answer A/B/C...) so the judge picks on quality alone, not by brand; if the judge fails it falls back to the first answer.
+5. **Result** — returns the best answer with the chosen model, the judge's reason, an estimated cost, and all candidates.
+
+**Components** (`fusefable/`)
+
+| File | Responsibility |
+|---|---|
+| `cli.py` | Typer CLI (`ask` / `config` / `mcp`), output modes |
+| `mcp_server.py` | MCP server exposing the `fuse_ask` tool |
+| `core.py` | shared `fuse()` entrypoint + model selection |
+| `config.py` | load/save `config.yaml` |
+| `wizard.py` | interactive setup (gateway vs single, API kind) |
+| `routing.py` | config → `(provider, model)` routes |
+| `providers/factory.py` | pick adapter by `kind` |
+| `providers/openai_compat.py` · `anthropic.py` · `google.py` | provider adapters |
+| `fanout.py` | parallel fan-out (drops failures) |
+| `judge.py` | anonymized judging |
+| `fusion.py` | orchestrator: fan-out → judge → `FinalAnswer` |
+| `cost.py` | token-based cost estimate |
+| `models.py` | dataclasses: `Completion`, `FinalAnswer`, `ProviderConfig` |
+
+## Development
+```bash
+pip install -e ".[dev,mcp]"
+pytest -q
+```
+
+## License
+MIT

fusefable-0.1.2/fusefable/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.2"

{fusefable-0.1.0 → fusefable-0.1.2}/fusefable/config.py

@@ -11,6 +11,7 @@ class SingleProvider:
     base_url: str
     api_key_env: str
     models: list[str] = field(default_factory=list)
+    kind: str = "openai_compat"   # openai_compat | anthropic | google
 
 
 @dataclass

fusefable-0.1.2/fusefable/providers/anthropic.py

@@ -0,0 +1,48 @@
+"""Anthropic native adapter — Messages API (/v1/messages).
+
+format ต่างจาก OpenAI: ใช้ header x-api-key + anthropic-version,
+response อยู่ใน content[].text และ usage.input_tokens/output_tokens.
+"""
+from __future__ import annotations
+import time
+import httpx
+from fusefable.models import Completion, ProviderConfig
+
+ANTHROPIC_VERSION = "2023-06-01"
+DEFAULT_MAX_TOKENS = 4096
+
+
+class AnthropicProvider:
+    def __init__(self, config: ProviderConfig, http: httpx.AsyncClient,
+                 max_tokens: int = DEFAULT_MAX_TOKENS):
+        self.config = config
+        self.http = http
+        self.max_tokens = max_tokens
+
+    async def complete(self, model: str, prompt: str) -> Completion:
+        url = f"{self.config.base_url.rstrip('/')}/messages"
+        headers = {
+            "x-api-key": self.config.api_key,
+            "anthropic-version": ANTHROPIC_VERSION,
+            "content-type": "application/json",
+        }
+        payload = {
+            "model": model,
+            "max_tokens": self.max_tokens,
+            "messages": [{"role": "user", "content": prompt}],
+        }
+        start = time.monotonic()
+        resp = await self.http.post(url, json=payload, headers=headers)
+        resp.raise_for_status()
+        data = resp.json()
+        latency = time.monotonic() - start
+        text = "".join(b.get("text", "") for b in data.get("content", [])
+                       if b.get("type") == "text")
+        usage = data.get("usage", {})
+        return Completion(
+            model=model,
+            text=text,
+            prompt_tokens=usage.get("input_tokens", 0),
+            completion_tokens=usage.get("output_tokens", 0),
+            latency_s=latency,
+        )

fusefable-0.1.2/fusefable/providers/factory.py

@@ -0,0 +1,25 @@
+"""เลือก provider class จาก 'kind' — รองรับหลายรูปแบบ API."""
+from __future__ import annotations
+import httpx
+from fusefable.models import ProviderConfig
+from fusefable.providers.openai_compat import OpenAICompatProvider
+from fusefable.providers.anthropic import AnthropicProvider
+from fusefable.providers.google import GoogleProvider
+
+# default base_url ของ native provider แต่ละเจ้า (เติมอัตโนมัติถ้าไม่ระบุ)
+NATIVE_BASE_URLS = {
+    "anthropic": "https://api.anthropic.com/v1",
+    "google": "https://generativelanguage.googleapis.com/v1beta",
+}
+
+_KINDS = {
+    "openai_compat": OpenAICompatProvider,
+    "anthropic": AnthropicProvider,
+    "google": GoogleProvider,
+}
+
+
+def make_provider(kind: str, config: ProviderConfig, http: httpx.AsyncClient):
+    """สร้าง provider ตาม kind. kind ที่ไม่รู้จัก → openai_compat."""
+    cls = _KINDS.get(kind, OpenAICompatProvider)
+    return cls(config, http)

fusefable-0.1.2/fusefable/providers/google.py

@@ -0,0 +1,38 @@
+"""Google Gemini native adapter — generateContent API.
+
+format ต่างจาก OpenAI: model อยู่ใน path, key เป็น query param,
+response อยู่ใน candidates[].content.parts[].text,
+usage ใน usageMetadata.promptTokenCount/candidatesTokenCount.
+"""
+from __future__ import annotations
+import time
+import httpx
+from fusefable.models import Completion, ProviderConfig
+
+
+class GoogleProvider:
+    def __init__(self, config: ProviderConfig, http: httpx.AsyncClient):
+        self.config = config
+        self.http = http
+
+    async def complete(self, model: str, prompt: str) -> Completion:
+        base = self.config.base_url.rstrip("/")
+        url = f"{base}/models/{model}:generateContent"
+        params = {"key": self.config.api_key}
+        payload = {"contents": [{"parts": [{"text": prompt}]}]}
+        start = time.monotonic()
+        resp = await self.http.post(url, params=params, json=payload)
+        resp.raise_for_status()
+        data = resp.json()
+        latency = time.monotonic() - start
+        parts = (data.get("candidates", [{}])[0]
+                 .get("content", {}).get("parts", []))
+        text = "".join(p.get("text", "") for p in parts)
+        usage = data.get("usageMetadata", {})
+        return Completion(
+            model=model,
+            text=text,
+            prompt_tokens=usage.get("promptTokenCount", 0),
+            completion_tokens=usage.get("candidatesTokenCount", 0),
+            latency_s=latency,
+        )

{fusefable-0.1.0 → fusefable-0.1.2}/fusefable/routing.py

@@ -3,23 +3,24 @@ import os
 import httpx
 from fusefable.config import Config
 from fusefable.models import ProviderConfig
-from fusefable.providers.openai_compat import OpenAICompatProvider
+from fusefable.providers.factory import make_provider
 
 
 def build_routes(cfg: Config, http: httpx.AsyncClient) -> list[tuple]:
     """แปลง Config → list ของ (provider, model)."""
     routes = []
     if cfg.mode == "gateway":
+        # gateway เป็น OpenAI-compatible เสมอ
         pc = ProviderConfig(cfg.gateway_name, cfg.gateway_base_url,
                             os.environ.get(cfg.api_key_env, ""))
-        prov = OpenAICompatProvider(pc, http)
+        prov = make_provider("openai_compat", pc, http)
         for model in cfg.models:
             routes.append((prov, model))
     else:
         for sp in cfg.providers:
             pc = ProviderConfig(sp.name, sp.base_url,
                                 os.environ.get(sp.api_key_env, ""))
-            prov = OpenAICompatProvider(pc, http)
+            prov = make_provider(sp.kind, pc, http)
             for model in sp.models:
                 routes.append((prov, model))
     return routes
@@ -30,7 +31,7 @@ def build_judge_provider(cfg: Config, http: httpx.AsyncClient):
     if cfg.mode == "gateway":
         pc = ProviderConfig(cfg.gateway_name, cfg.gateway_base_url,
                             os.environ.get(cfg.api_key_env, ""))
-    else:
-        sp = cfg.providers[0]
-        pc = ProviderConfig(sp.name, sp.base_url, os.environ.get(sp.api_key_env, ""))
-    return OpenAICompatProvider(pc, http)
+        return make_provider("openai_compat", pc, http)
+    sp = cfg.providers[0]
+    pc = ProviderConfig(sp.name, sp.base_url, os.environ.get(sp.api_key_env, ""))
+    return make_provider(sp.kind, pc, http)

{fusefable-0.1.0 → fusefable-0.1.2}/fusefable/wizard.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 from fusefable.config import Config, SingleProvider
+from fusefable.providers.factory import NATIVE_BASE_URLS
 
 # base_url ของ AI gateway ที่รู้จัก (OpenAI-compatible) — เติมอัตโนมัติ
 # เจ้าที่ไม่อยู่ในนี้ก็ยังใช้ได้ แค่ผู้ใช้พิมพ์ base_url เอง → รองรับทุกเจ้า
@@ -75,11 +76,17 @@ def run_wizard(prompt=input) -> Config:
     for i in range(n):
         print(f"-- เจ้าที่ {i + 1} --")
         name = prompt("  ชื่อ: ").strip()
-        base = prompt("  base_url: ").strip()
+        kind = prompt("  ชนิด API [openai_compat/anthropic/google] "
+                      "(Enter = openai_compat): ").strip() or "openai_compat"
+        base = NATIVE_BASE_URLS.get(kind)   # เติมอัตโนมัติสำหรับ native
+        if base:
+            print(f"  (เติม base_url อัตโนมัติ: {base})")
+        else:
+            base = prompt("  base_url: ").strip()
         key_env = prompt("  ชื่อ env var ของ API key: ").strip()
         models_raw = prompt("  โมเดล (คั่นด้วย comma): ").strip()
         models = [m.strip() for m in models_raw.split(",") if m.strip()]
-        providers.append({"name": name, "base_url": base,
+        providers.append({"name": name, "base_url": base, "kind": kind,
                           "api_key_env": key_env, "models": models})
     judge = prompt("judge model: ").strip()
     return build_config_from_answers({