coderouter-cli 2.7.5__py3-none-any.whl → 2.7.7__py3-none-any.whl

coderouter/config/schemas.py

@@ -163,6 +163,125 @@ class CostConfig(BaseModel):
     )
 
 
+class AgentCliConfig(BaseModel):
+    """External coding-agent CLI settings for ``kind="agent_cli"`` providers.
+
+    Introduced by the external-agents-adapter design (Phase 1). One
+    ``agent_cli`` sub-config drives the :class:`AgentCliAdapter`, which
+    invokes an external coding-agent CLI (codex / gemini / grok / claude)
+    in a single one-shot ``exec`` and returns the final answer as one
+    ``prompt in → text out`` transformation. Phase 1a implements the
+    ``claude`` (Claude Code CLI) target only; the other agents are declared
+    at the schema level so configs are forward-compatible, but the adapter
+    rejects them until their phase lands.
+
+    Follows the ``extra="forbid"`` convention used across this module so a
+    typo'd key fails at config-load rather than being silently ignored.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    agent: Literal["codex", "gemini", "grok", "claude"] = Field(
+        ...,
+        description="External coding-agent CLI to invoke. Phase 1a: 'claude' only.",
+    )
+    command: str | None = Field(
+        default=None,
+        description=(
+            "CLI executable name or absolute path (resolved via PATH). "
+            "When unset, defaults to the ``agent`` name."
+        ),
+    )
+    workdir: str | None = Field(
+        default=None,
+        description=(
+            "Working directory for the one-shot exec. ``~`` / env-var "
+            "expansion is applied. When unset, a dedicated isolated "
+            "directory (``~/.coderouter/agents/<name>``) is used."
+        ),
+    )
+    exec_timeout_s: float = Field(
+        default=600.0,
+        ge=1.0,
+        le=1800.0,
+        description=(
+            "Forced timeout (seconds) for the one-shot exec. Independent "
+            "of ``ProviderConfig.timeout_s`` — the CLI has no built-in "
+            "wall clock so this is enforced with an asyncio watchdog + "
+            "process-group SIGKILL."
+        ),
+    )
+    allow_file_writes: bool = Field(
+        default=False,
+        description=(
+            "Allow the agent to write to the filesystem. Default False "
+            "(read-only). When False the sandbox mapping is clamped to "
+            "read-only regardless of ``sandbox_mode`` (defense in depth)."
+        ),
+    )
+    sandbox_mode: Literal["read_only", "edit", "full_auto"] = Field(
+        default="read_only",
+        description=(
+            "Source mode mapped onto each CLI's sandbox / approval flags. "
+            "Default read_only maps to claude ``--permission-mode plan``."
+        ),
+    )
+    model: str | None = Field(
+        default=None,
+        description=(
+            "Model name passed to the CLI's ``--model``. When unset, "
+            "``ProviderConfig.model`` is used."
+        ),
+    )
+    max_turns: int | None = Field(
+        default=8,
+        ge=1,
+        le=50,
+        description=(
+            "Turn cap. Passed to the CLI's ``--max-turns`` where supported "
+            "(codex ignores it — the CLI has no such flag)."
+        ),
+    )
+    passthrough_env: list[str] = Field(
+        default_factory=list,
+        description=(
+            "Allowlist of environment variable NAMES forwarded from the "
+            "parent process into the child. The child otherwise inherits "
+            "no parent environment (subscription-first auth policy). "
+            "``ANTHROPIC_API_KEY`` is NOT forwarded unless listed here."
+        ),
+    )
+    agent_depth_limit: int = Field(
+        default=2,
+        ge=1,
+        le=4,
+        description=(
+            "Recursion nesting cap. ``CODEROUTER_AGENT_DEPTH`` is "
+            "propagated (incremented) into the child; ``generate()`` "
+            "refuses when the current depth is at or above this limit."
+        ),
+    )
+
+    @model_validator(mode="after")
+    def _resolve_and_check(self) -> AgentCliConfig:
+        """Default ``command`` to ``agent`` and reject contradictory sandbox.
+
+        Rule (design §5.2.1 #2): ``allow_file_writes=True`` together with
+        ``sandbox_mode="read_only"`` is contradictory — the operator asked
+        for writes while pinning a read-only sandbox. Fail fast at load,
+        matching the module's other cross-field validators.
+        """
+        if self.command is None:
+            self.command = self.agent
+        if self.allow_file_writes and self.sandbox_mode == "read_only":
+            raise ValueError(
+                "agent_cli: allow_file_writes=True conflicts with "
+                "sandbox_mode='read_only'. Set sandbox_mode to 'edit' or "
+                "'full_auto' to permit writes, or keep allow_file_writes=False."
+            )
+        return self
+
+
 class ProviderConfig(BaseModel):
     """A single provider entry from providers.yaml.
 
@@ -170,20 +289,26 @@ class ProviderConfig(BaseModel):
         - Local llama.cpp server: kind=openai_compat, base_url=http://localhost:8080/v1
         - OpenRouter free: kind=openai_compat, base_url=https://openrouter.ai/api/v1
         - (future) Anthropic: kind=anthropic, base_url=https://api.anthropic.com
+        - External agent CLI: kind=agent_cli, agent_cli={agent: claude, ...}
     """
 
     model_config = ConfigDict(extra="forbid")
 
     name: str = Field(..., description="Unique identifier used in profiles.yaml")
-    kind: Literal["openai_compat", "anthropic"] = Field(
+    kind: Literal["openai_compat", "anthropic", "agent_cli"] = Field(
         default="openai_compat",
         description=(
             "Adapter type. 'openai_compat' covers llama.cpp / Ollama / "
             "OpenRouter / LM Studio / Together / Groq. 'anthropic' is the "
-            "native Anthropic Messages API passthrough (v0.3.x)."
+            "native Anthropic Messages API passthrough (v0.3.x). 'agent_cli' "
+            "invokes an external coding-agent CLI one-shot (see AgentCliConfig)."
         ),
     )
-    base_url: HttpUrl
+    # base_url is required for HTTP-backed adapters (openai_compat / anthropic)
+    # but meaningless for agent_cli (which shells out to a local CLI rather
+    # than calling a URL). It is optional at the field level and enforced per
+    # kind by ``_check_kind_requirements`` below.
+    base_url: HttpUrl | None = None
     model: str = Field(..., description="Upstream model id sent in the request body")
     api_key_env: str | None = Field(
         default=None,
@@ -243,6 +368,14 @@ class ProviderConfig(BaseModel):
 
     capabilities: Capabilities = Field(default_factory=Capabilities)
 
+    # kind="agent_cli": required external coding-agent CLI settings. Opt-in
+    # (default None) exactly like ``restart_command`` — only meaningful when
+    # ``kind == "agent_cli"``, and enforced by ``_check_kind_requirements``.
+    agent_cli: AgentCliConfig | None = Field(
+        default=None,
+        description="Required when kind='agent_cli': external agent CLI settings.",
+    )
+
     cost: CostConfig | None = Field(
         default=None,
         description=(
@@ -298,6 +431,32 @@ class ProviderConfig(BaseModel):
         validate_output_filters(self.output_filters)
         return self
 
+    @model_validator(mode="after")
+    def _check_kind_requirements(self) -> ProviderConfig:
+        """Enforce per-``kind`` field requirements (external-agents design §5.2.2).
+
+        - HTTP-backed adapters (``openai_compat`` / ``anthropic``) require a
+          ``base_url`` — they have nowhere to send the request otherwise.
+          ``base_url`` was relaxed to Optional so ``agent_cli`` providers can
+          omit it; this validator restores the required-ness for the HTTP kinds.
+        - ``agent_cli`` requires the ``agent_cli`` sub-config (the adapter has
+          no CLI to invoke without it).
+
+        Same fast-fail philosophy as ``_check_output_filters_known`` — a
+        misconfigured provider surfaces at config-load, not at first request.
+        """
+        if self.kind in ("openai_compat", "anthropic") and self.base_url is None:
+            raise ValueError(
+                f"provider {self.name!r}: base_url is required for "
+                f"kind={self.kind!r}."
+            )
+        if self.kind == "agent_cli" and self.agent_cli is None:
+            raise ValueError(
+                f"provider {self.name!r}: agent_cli sub-config is required "
+                f"for kind='agent_cli'."
+            )
+        return self
+
 
 class FallbackChain(BaseModel):
     """An ordered list of provider names to try in sequence.

coderouter/gguf_introspect.py

@@ -136,6 +136,17 @@ class GGUFInfo:
     n_kv_heads: int | None
     file_type: int | None
     file_size_bytes: int
+    n_nextn: int | None = None
+
+    @property
+    def supports_mtp(self) -> bool:
+        """True when the GGUF embeds Multi-Token-Prediction (nextn) layers.
+
+        Derived from ``{arch}.nextn_predict_layers`` — a positive count means
+        the main model carries MTP/nextn tensors and can drive llama.cpp's
+        ``--spec-type draft-mtp`` without a separate draft gguf.
+        """
+        return bool(self.n_nextn and self.n_nextn > 0)
 
     @property
     def quant_name(self) -> str | None:
@@ -224,6 +235,10 @@ _KEY_BLOCK_COUNT = ".block_count"
 _KEY_EMBED_LEN = ".embedding_length"
 _KEY_HEAD_COUNT = ".attention.head_count"
 _KEY_HEAD_COUNT_KV = ".attention.head_count_kv"
+# Number of Multi-Token-Prediction (nextn) layers embedded in the main model
+# (e.g. ``glm4moe.nextn_predict_layers``). A positive value means the GGUF can
+# drive llama.cpp speculative decoding via ``--spec-type draft-mtp`` alone.
+_KEY_NEXTN = ".nextn_predict_layers"
 
 
 def read_gguf_metadata(path: str | Path) -> GGUFInfo:
@@ -245,6 +260,7 @@ def read_gguf_metadata(path: str | Path) -> GGUFInfo:
     n_heads: int | None = None
     n_kv_heads: int | None = None
     file_type: int | None = None
+    n_nextn: int | None = None
 
     with p.open("rb") as fh:
         magic = fh.read(4)
@@ -275,6 +291,8 @@ def read_gguf_metadata(path: str | Path) -> GGUFInfo:
                 n_kv_heads = value
             elif key.endswith(_KEY_HEAD_COUNT) and isinstance(value, int):
                 n_heads = value
+            elif key.endswith(_KEY_NEXTN) and isinstance(value, int):
+                n_nextn = value
 
     return GGUFInfo(
         architecture=arch,
@@ -284,6 +302,7 @@ def read_gguf_metadata(path: str | Path) -> GGUFInfo:
         n_kv_heads=n_kv_heads,
         file_type=file_type,
         file_size_bytes=file_size,
+        n_nextn=n_nextn,
     )
 
 

coderouter/ingress/launcher_routes.py

@@ -30,6 +30,7 @@ import secrets
 import shlex
 import shutil
 import subprocess
+import time
 import uuid
 from collections import deque
 from dataclasses import dataclass, field
@@ -40,6 +41,7 @@ from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import HTMLResponse
 from pydantic import BaseModel
 
+from coderouter.launcher_speculative import resolve_speculative
 from coderouter.logging import get_logger
 
 logger = get_logger(__name__)
@@ -115,9 +117,23 @@ class ManagedProcess:
     options: dict[str, Any]
     extra_args: str
     status: str = "starting"   # "starting" | "running" | "stopped" | "error"
+    # MTP / speculative-decoding controls (defaults keep existing call sites
+    # working). Recorded for introspection; the resolved flags live in the cmd.
+    draft_model_path: str | None = None
+    mtp_mode: str = "auto"
     pid: int | None = None
     returncode: int | None = None
     log_tail: deque = field(default_factory=lambda: deque(maxlen=200))
+    # MTP auto-fallback state. When the speculative flags were added by AUTO
+    # detection and the child dies during startup, the process is relaunched
+    # ONCE without them (some archs' draft-mtp support in llama.cpp is
+    # immature and crashes the context init). These fields make that possible
+    # and impossible to loop.
+    spec_tokens: list = field(default_factory=list)
+    spec_auto: bool = False
+    mtp_fallback_done: bool = False
+    fallback_cmd: list | None = None
+    started_at: float = 0.0
     # asyncio subprocess handle — not serialised
     _proc: Any = field(default=None, repr=False, compare=False)
 
@@ -208,8 +224,15 @@ _BACKEND_DEFAULTS: dict[str, str] = {
 #   - llama.cpp: ``-m`` / ``--model`` select the GGUF file.
 #   - vllm / mlx: ``--model`` selects the model; ``-m`` selects the python
 #     module that ``_build_cmd`` pins, so it must not be re-specified either.
+#   - llama.cpp: the draft/MTP model is likewise set only via the dedicated
+#     ``draft_model_path`` field, so its aliases (``-md`` / ``--model-draft``
+#     / ``--spec-draft-model``) are rejected in options / extra_args too. The
+#     remaining spec knobs (``--spec-type``, ``--spec-draft-n-max`` …) stay
+#     free-form.
 _MODEL_FLAGS: dict[str, frozenset[str]] = {
-    "llama.cpp": frozenset({"-m", "--model"}),
+    "llama.cpp": frozenset(
+        {"-m", "--model", "-md", "--model-draft", "--spec-draft-model"}
+    ),
     "vllm": frozenset({"-m", "--model"}),
     "mlx": frozenset({"-m", "--model"}),
 }
@@ -407,6 +430,24 @@ def _resolve_within_model_dirs(model_path: str, model_dirs: list[str]) -> Path:
     raise ValueError("model_path is not under any configured model_dirs.")
 
 
+def _option_tokens(options: dict[str, Any]) -> list[str]:
+    """Flatten an ``options`` dict into CLI tokens (``{flag: val}`` semantics).
+
+    Boolean values become a bare flag when true and vanish when false;
+    everything else becomes ``[flag, str(val)]``. Shared by ``_build_cmd`` and
+    ``api_start`` so the tokens fed to ``resolve_speculative`` match exactly
+    what lands on the command line (no double-parsing drift).
+    """
+    tokens: list[str] = []
+    for flag, val in options.items():
+        if isinstance(val, bool):
+            if val:
+                tokens.append(flag)
+        else:
+            tokens.extend([flag, str(val)])
+    return tokens
+
+
 def _build_cmd(
     backend: str,
     model_path: str,
@@ -414,17 +455,27 @@ def _build_cmd(
     options: dict[str, Any],
     extra_args: str,
     binary: str | None = None,
+    spec_tokens: list[str] | None = None,
 ) -> list[str]:
     """Build the CLI command list for the given backend and options.
 
     ``binary`` overrides the default executable (``llama-server`` /
     ``python``).  When None, the default is used and PATH resolution
     is left to the OS.
+
+    ``spec_tokens`` are pre-resolved speculative-decoding / MTP flags
+    (from :func:`coderouter.launcher_speculative.resolve_speculative`).
+    For llama.cpp they are appended right after the port args and BEFORE
+    the profile / extra args. They are trusted (the launcher, not the
+    caller, produced them) so they bypass the model-override guard even
+    though they may contain ``--model-draft``.
     """
     exe = _resolve_binary(backend, binary)
 
     if backend == "llama.cpp":
         cmd: list[str] = [exe, "-m", model_path, "--port", str(port)]
+        if spec_tokens:
+            cmd.extend(spec_tokens)
     elif backend == "vllm":
         cmd = [
             exe, "-m", "vllm.entrypoints.openai.api_server",
@@ -446,12 +497,7 @@ def _build_cmd(
     # H8: reject model-path re-specification via options keys.
     _assert_no_model_override(backend, list(options.keys()))
 
-    for flag, val in options.items():
-        if isinstance(val, bool):
-            if val:
-                cmd.append(flag)
-        else:
-            cmd.extend([flag, str(val)])
+    cmd.extend(_option_tokens(options))
 
     if extra_args.strip():
         extra_tokens = shlex.split(extra_args)
@@ -474,12 +520,37 @@ def _build_cmd(
 # recover by reading the buffered chunk and continuing so log tailing survives.
 _LOG_STREAM_LIMIT = 256 * 1024  # 256 KB
 
+# Window (seconds) after spawn in which a non-zero exit is treated as a
+# startup crash eligible for the MTP auto-fallback. A backend that ran fine
+# for longer and then died is a normal crash, not a load-time failure, so it
+# is never retried.
+_MTP_FALLBACK_WINDOW_SECS = 180.0
 
-async def _tail_logs(proc: ManagedProcess) -> None:
-    """Read stdout+stderr into proc.log_tail until the process exits."""
+
+def _should_mtp_fallback(proc: ManagedProcess) -> bool:
+    """True when a just-crashed process qualifies for the one-shot MTP retry.
+
+    Only auto-detected speculative launches that die within the startup
+    window are eligible, and only once (guarded by ``mtp_fallback_done``).
+    """
     p = proc._proc
-    if p is None:
-        return
+    rc = p.returncode if p is not None else proc.returncode
+    return (
+        proc.spec_auto
+        and not proc.mtp_fallback_done
+        and bool(proc.fallback_cmd)
+        and rc not in (0, None)
+        and (time.monotonic() - proc.started_at) <= _MTP_FALLBACK_WINDOW_SECS
+    )
+
+
+async def _tail_logs(proc: ManagedProcess) -> None:
+    """Read stdout+stderr into proc.log_tail until the process exits.
+
+    Loops so that a one-shot MTP fallback (relaunch without the auto-detected
+    speculative flags) can be tailed by the same task. The loop exits as soon
+    as no fallback applies.
+    """
 
     async def _drain(stream: asyncio.StreamReader | None) -> None:
         if stream is None:
@@ -505,14 +576,53 @@ async def _tail_logs(proc: ManagedProcess) -> None:
                 break
             proc.log_tail.append(line.decode(errors="replace").rstrip())
 
-    await asyncio.gather(_drain(p.stdout), _drain(p.stderr))
-    await p.wait()
-    proc.returncode = p.returncode
-    proc.pid = None
-    proc.status = "stopped" if (p.returncode or 0) == 0 else "error"
-    proc.log_tail.append(
-        f"[launcher] process exited with code {p.returncode}"
-    )
+    while True:
+        p = proc._proc
+        if p is None:
+            return
+
+        await asyncio.gather(_drain(p.stdout), _drain(p.stderr))
+        await p.wait()
+        proc.returncode = p.returncode
+        proc.pid = None
+        proc.status = "stopped" if (p.returncode or 0) == 0 else "error"
+        proc.log_tail.append(
+            f"[launcher] process exited with code {p.returncode}"
+        )
+
+        if not _should_mtp_fallback(proc):
+            return
+
+        # Auto-detected MTP crashed during startup — retry ONCE without the
+        # speculative flags. The port is unchanged, so the existing provider
+        # registration still stands (do not re-register).
+        rc = proc.returncode
+        proc.mtp_fallback_done = True
+        proc.log_tail.append(
+            f"[launcher] MTP startup failure detected (exit code {rc}); "
+            "retrying without speculative decoding"
+        )
+        proc.log_tail.append(
+            f"[launcher] cmd: {' '.join(proc.fallback_cmd)}"
+        )
+        try:
+            p = await asyncio.create_subprocess_exec(
+                *proc.fallback_cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                limit=_LOG_STREAM_LIMIT,
+            )
+        except (FileNotFoundError, OSError) as exc:
+            proc.log_tail.append(f"[launcher] fallback relaunch failed: {exc}")
+            proc.status = "error"
+            return
+        proc._proc = p
+        proc.pid = p.pid
+        proc.status = "running"
+        proc.returncode = None
+        proc.started_at = time.monotonic()
+        proc.log_tail.append(f"[launcher] started PID {p.pid}")
+        # Loop to tail the relaunched process.
 
 
 async def shutdown_launcher(app: Any) -> None:
@@ -555,6 +665,11 @@ class StartRequest(BaseModel):
     port: int
     options: dict[str, Any] = {}
     extra_args: str = ""
+    # MTP / speculative-decoding controls (llama.cpp only). ``draft_model_path``
+    # is an explicit companion draft/MTP gguf; ``mtp_mode`` is "auto" (detect)
+    # or "off" (never emit speculative flags).
+    draft_model_path: str | None = None
+    mtp_mode: str = "auto"
 
 
 # ---------------------------------------------------------------------------
@@ -690,15 +805,69 @@ async def api_start(req: StartRequest, request: Request) -> dict[str, Any]:
         if bc and bc.binary:
             configured_binary = bc.binary
 
+    # Validate the MTP mode up front (only "auto" / "off" are accepted).
+    if req.mtp_mode not in ("auto", "off"):
+        raise HTTPException(
+            status_code=400,
+            detail=f"mtp_mode must be 'auto' or 'off', got {req.mtp_mode!r}.",
+        )
+
+    # Build the user token list once (options flags + extra_args) so
+    # resolve_speculative sees exactly what _build_cmd will emit. shlex.split
+    # can raise on unbalanced quotes → surface as 400 like other bad input.
+    try:
+        user_tokens = _option_tokens(req.options)
+        if req.extra_args.strip():
+            user_tokens += shlex.split(req.extra_args)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    # Resolve MTP / speculative-decoding flags (llama.cpp only; no-op elsewhere).
+    try:
+        spec_tokens, spec_notes = resolve_speculative(
+            req.backend,
+            req.model_path,
+            req.draft_model_path,
+            req.mtp_mode,
+            user_tokens,
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
     try:
         cmd = _build_cmd(
             req.backend, req.model_path, req.port,
             req.options, req.extra_args,
             binary=configured_binary,
+            spec_tokens=spec_tokens,
         )
     except ValueError as exc:
         raise HTTPException(status_code=400, detail=str(exc)) from exc
 
+    # Speculative flags qualify for the one-shot startup-crash fallback only
+    # when they came from AUTO detection (mtp_mode="auto", no explicit draft
+    # model, and detection actually emitted flags). Explicit draft paths and
+    # operator-supplied --spec-type are never auto-retried. The fallback cmd
+    # is rebuilt from scratch with spec_tokens=None (exact — never spliced).
+    spec_auto = (
+        req.mtp_mode == "auto"
+        and req.draft_model_path is None
+        and bool(spec_tokens)
+    )
+    fallback_cmd: list[str] | None = None
+    if spec_auto:
+        try:
+            fallback_cmd = _build_cmd(
+                req.backend, req.model_path, req.port,
+                req.options, req.extra_args,
+                binary=configured_binary,
+                spec_tokens=None,
+            )
+        except ValueError:
+            # A failure to rebuild the non-spec command simply disables the
+            # fallback; it must never block the primary start.
+            fallback_cmd = None
+
     proc_id = uuid.uuid4().hex[:8]
     proc = ManagedProcess(
         id=proc_id,
@@ -708,9 +877,16 @@ async def api_start(req: StartRequest, request: Request) -> dict[str, Any]:
         port=req.port,
         options=req.options,
         extra_args=req.extra_args,
+        draft_model_path=req.draft_model_path,
+        mtp_mode=req.mtp_mode,
         status="starting",
+        spec_tokens=spec_tokens,
+        spec_auto=spec_auto and fallback_cmd is not None,
+        fallback_cmd=fallback_cmd,
     )
     proc.log_tail.append(f"[launcher] cmd: {' '.join(cmd)}")
+    for note in spec_notes:
+        proc.log_tail.append(f"[launcher] {note}")
 
     try:
         p = await asyncio.create_subprocess_exec(
@@ -732,6 +908,7 @@ async def api_start(req: StartRequest, request: Request) -> dict[str, Any]:
     proc._proc = p
     proc.pid = p.pid
     proc.status = "running"
+    proc.started_at = time.monotonic()
     proc.log_tail.append(f"[launcher] started PID {p.pid}")
 
     _registry(request).add(proc)
@@ -767,6 +944,7 @@ async def api_start(req: StartRequest, request: Request) -> dict[str, Any]:
         "pid": p.pid,
         "command": cmd,
         "provider_sync": provider_sync,
+        "speculative": spec_tokens,
     }
 
 
@@ -971,6 +1149,20 @@ _LAUNCHER_HTML = r"""<!doctype html>
         <div id="profile-args" class="mt-1 text-xs font-mono text-slate-400 bg-slate-800/50 rounded p-2 hidden"></div>
       </div>
 
+      <div class="grid grid-cols-2 gap-2">
+        <div>
+          <label class="block text-xs text-slate-400 mb-1">MTP/draft gguf (空欄で自動検出)</label>
+          <input id="f-draft" type="text" placeholder="companion .gguf (任意)" />
+        </div>
+        <div>
+          <label class="block text-xs text-slate-400 mb-1">MTP</label>
+          <select id="f-mtp">
+            <option value="auto">auto</option>
+            <option value="off">off</option>
+          </select>
+        </div>
+      </div>
+
       <div>
         <div class="flex items-center justify-between mb-1">
           <label class="block text-xs text-slate-400">追加オプション(自由入力)</label>
@@ -1292,6 +1484,8 @@ _LAUNCHER_HTML = r"""<!doctype html>
     const backend = document.getElementById("f-backend").value;
     const model = document.getElementById("f-model").value.trim();
     const extra = document.getElementById("f-extra").value.trim();
+    const draft = document.getElementById("f-draft").value.trim();
+    const mtp = document.getElementById("f-mtp").value;
 
     if (!name) { showLaunchErr("名前を入力してください"); return; }
     if (!model) { showLaunchErr("モデルパスを入力してください"); return; }
@@ -1306,7 +1500,8 @@ _LAUNCHER_HTML = r"""<!doctype html>
         method: "POST",
         headers: authHeaders({"Content-Type": "application/json"}),
         body: JSON.stringify({name, backend, model_path: model, port,
-                              options: selectedProfileArgs(), extra_args: extra}),
+                              options: selectedProfileArgs(), extra_args: extra,
+                              draft_model_path: draft || null, mtp_mode: mtp}),
       });
       const d = await res.json();
       if (!res.ok) { showLaunchErr(d.detail || "起動失敗"); return; }