crabcode 0.1.8__tar.gz → 0.1.10__tar.gz

{crabcode-0.1.8 → crabcode-0.1.10}/.github/workflows/client-packages.yml

@@ -1,10 +1,17 @@
 name: Client Packages
 run-name: Client packages · ${{ github.ref_name }} · ${{ github.run_number }}
 
-# Download the packages from this run's Artifacts and upload them manually.
-# Python Release/PyPI publishing is intentionally independent.
+# Keep this filename: both registries' trusted publishers are bound to it.
+# Manual runs build artifacts only. Releases also upload assets; stable releases
+# publish the same VSIXs to both registries. Python/PyPI remains independent.
 on:
   workflow_dispatch:
+  release:
+    types: [published]
+
+concurrency:
+  group: client-packages-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: false
 
 permissions:
   contents: read
@@ -32,6 +39,11 @@ jobs:
           python scripts/sync_version.py --check
           python scripts/package_clients.py check
           python packages/vscode/scripts/gen-types.py --check
+      - name: Check release tag matches client versions
+        if: github.event_name == 'release'
+        env:
+          RELEASE_TAG: ${{ github.event.release.tag_name }}
+        run: python scripts/package_clients.py check --release-tag "$RELEASE_TAG"
       - run: npm ci
         working-directory: packages/vscode
       - run: npm run lint
@@ -105,6 +117,8 @@ jobs:
     timeout-minutes: 20
     needs: native
     runs-on: ubuntu-24.04
+    permissions:
+      contents: write
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
@@ -144,7 +158,61 @@ jobs:
       - name: Add download instructions
         run: |
           echo '## VSIX packages' >> "$GITHUB_STEP_SUMMARY"
-          echo 'Download **vsix-${{ github.run_number }}** from Artifacts and unzip it. It contains the universal CrabCode main extension, three platform Computer Use companions, the all-platform companion, and SHA256SUMS. Upload the VSIXs to the extension store manually.' >> "$GITHUB_STEP_SUMMARY"
+          echo 'Download **vsix-${{ github.run_number }}** from Artifacts and unzip it. It contains the universal CrabCode main extension, three platform Computer Use companions, the all-platform companion, and SHA256SUMS. Release runs also attach these VSIXs to the release; stable releases publish them to both extension stores.' >> "$GITHUB_STEP_SUMMARY"
+      - name: Upload VSIXs to GitHub Release
+        if: github.event_name == 'release'
+        working-directory: dist/vsix
+        env:
+          GH_TOKEN: ${{ github.token }}
+          RELEASE_TAG: ${{ github.event.release.tag_name }}
+        run: |
+          cp SHA256SUMS vsix-SHA256SUMS
+          gh release upload "$RELEASE_TAG" ./*.vsix vsix-SHA256SUMS --repo "$GITHUB_REPOSITORY" --clobber
+
+  publish-extensions:
+    name: Publish VSIXs · ${{ matrix.registry }}
+    if: github.event_name == 'release' && !github.event.release.prerelease
+    needs: vsix
+    timeout-minutes: 30
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: read
+      id-token: write
+    strategy:
+      fail-fast: false
+      matrix:
+        registry: [marketplace, open-vsx]
+    steps:
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+      - uses: actions/download-artifact@v4
+        with:
+          name: vsix-${{ github.run_number }}
+          path: dist/vsix
+      - name: Verify downloaded VSIX checksums
+        working-directory: dist/vsix
+        run: sha256sum --check SHA256SUMS
+      - name: Install Marketplace publisher with OIDC support
+        if: matrix.registry == 'marketplace'
+        run: npm install --global @vscode/vsce@4.1.0
+      - name: Install Open VSX publisher with OIDC support
+        if: matrix.registry == 'open-vsx'
+        run: npm install --global ovsx@1.3.0
+      # Publish prebuilt packages without rerunning vscode:prepublish. Each call
+      # obtains its own short-lived credential. Duplicates are safe to retry.
+      - name: Publish all VSIXs to Visual Studio Marketplace
+        if: matrix.registry == 'marketplace'
+        run: |
+          for package in dist/vsix/*.vsix; do
+            vsce publish --packagePath "$package" --oidc --skip-duplicate
+          done
+      - name: Publish all VSIXs to Open VSX
+        if: matrix.registry == 'open-vsx'
+        run: |
+          for package in dist/vsix/*.vsix; do
+            ovsx publish "$package" --trusted-publishing --skip-duplicate
+          done
 
   desktop:
     name: Desktop installer · ${{ matrix.platform }}
@@ -161,6 +229,8 @@ jobs:
           - platform: win32-x64
             os: windows-2022
     runs-on: ${{ matrix.os }}
+    permissions:
+      contents: write
     env:
       MACOSX_DEPLOYMENT_TARGET: '11.0'
     steps:
@@ -212,3 +282,13 @@ jobs:
         run: |
           echo '## Desktop installer' >> "$GITHUB_STEP_SUMMARY"
           echo 'Download **desktop-${{ matrix.platform }}-${{ github.run_number }}** from Artifacts. It contains the DMG or MSI and SHA256SUMS.' >> "$GITHUB_STEP_SUMMARY"
+      - name: Upload Desktop installer to GitHub Release
+        if: github.event_name == 'release'
+        shell: bash
+        working-directory: dist/desktop
+        env:
+          GH_TOKEN: ${{ github.token }}
+          RELEASE_TAG: ${{ github.event.release.tag_name }}
+        run: |
+          cp SHA256SUMS desktop-${{ matrix.platform }}-SHA256SUMS
+          gh release upload "$RELEASE_TAG" ./crab-desktop-* desktop-${{ matrix.platform }}-SHA256SUMS --repo "$GITHUB_REPOSITORY" --clobber

crabcode-0.1.10/CLIENT_PACKAGING.md

@@ -0,0 +1,81 @@
+# Client packaging and releases
+
+`.github/workflows/client-packages.yml` builds the VS Code extensions and Desktop
+installers from the same commit. It builds Computer Use once on each native
+runner, then reuses those bundles for the extensions and installers.
+
+| Trigger | Actions artifacts | GitHub Release assets | Extension stores |
+| --- | --- | --- | --- |
+| Actions → Client Packages → Run workflow | Yes | No | No |
+| Publish a stable GitHub Release | Yes | Yes | Marketplace and Open VSX |
+| Publish a prerelease on GitHub | Yes | Yes | No |
+
+The workflow must be committed before creating the release tag. The tag must be
+the version in the checked-out client manifests, with an optional `v` prefix
+(for example, `0.1.10` or `v0.1.10`). Version mismatches fail before native builds.
+Use a new version when changing published packages; existing registry versions
+are not replaced. The independent `python-publish.yml` workflow continues to
+handle Python/PyPI publishing.
+
+## Release downloads
+
+For version `<version>`, the release receives:
+
+- `crabcode-<version>.vsix`: universal main extension.
+- `crabcode-computer-use-<version>-darwin-arm64.vsix`.
+- `crabcode-computer-use-<version>-darwin-x64.vsix`.
+- `crabcode-computer-use-<version>-win32-x64.vsix`.
+- `crabcode-computer-use-<version>-universal.vsix`: all three native bundles.
+- `crab-desktop-<version>-darwin-arm64.dmg`: Apple Silicon Mac.
+- `crab-desktop-<version>-darwin-x64.dmg`: Intel Mac.
+- `crab-desktop-<version>-win32-x64.msi`: Windows x64.
+
+The VSIXs share `vsix-SHA256SUMS`. Each Desktop installer has its own
+`desktop-<platform>-SHA256SUMS`, so concurrently finishing jobs cannot overwrite
+each other's checksums. Each build uploads its own release assets immediately;
+Desktop uploads do not depend on extension-store publication.
+
+Actions retains the packaged downloads for 30 days and intermediate native
+bundles for 7 days. Release attachments remain available independently of those
+artifact retention periods. Rerunning a release job replaces its same-named
+GitHub attachments. Registry publishing skips versions already present, and
+the two stores run independently so a failure in one does not cancel the other.
+
+## Trusted publishing
+
+Both registries must authorize repository owner `ylzz1997`, repository `crabcode`,
+workflow **`client-packages.yml`**, with **no environment restriction**. Keep the
+workflow filename unchanged unless the policies are also updated.
+
+- Visual Studio Marketplace: create a Trusted Publishing policy under publisher
+  `crabcode`.
+- Open VSX: configure a trusted publisher for each extension, `crabcode` and
+  `crabcode-computer-use`, in namespace `crabcode`.
+
+Only the publishing job requests `id-token: write`. It uses Node 22,
+`@vscode/vsce@4.1.0` with `--oidc`, and `ovsx@1.3.0` with
+`--trusted-publishing`. It verifies artifact SHA256 checksums and publishes the
+already-built VSIXs, without rerunning native build or prepublish hooks. No
+`VSCE_PAT` or `OVSX_PAT` secret is required. Release uploads use GitHub's built-in
+token with `contents: write` in the corresponding build jobs.
+
+See the [Marketplace documentation](https://code.visualstudio.com/api/working-with-extensions/publishing-extension#publish-with-github-actions-and-trusted-publishing)
+and [Open VSX CLI documentation](https://github.com/eclipse-openvsx/openvsx/blob/main/cli/README.md#trusted-publishing).
+
+## Verification and signing
+
+The workflow checks synchronized versions, extension icons, client tests,
+Computer Use tests, native architectures and runtime metadata. It inspects the
+packaged VSIX payloads, executable permissions, localization and icon bytes.
+Desktop checks inspect the actual DMG/MSI contents on their native OS runners.
+The companion's `logo.png` is a 512-pixel rendition of the native Computer Use
+icon; `node packages/computer-use/scripts/build-icons.mjs` regenerates it alongside
+the native icons on macOS.
+
+Optional macOS signing secrets are `CRABCODE_SIGNING_CERTIFICATE_P12_BASE64`,
+`CRABCODE_SIGNING_CERTIFICATE_PASSWORD`, and `CRABCODE_SIGNING_IDENTITY`.
+Without them, macOS builds use ad-hoc signing. The workflow does not notarize
+macOS installers or Authenticode-sign Windows installers.
+
+A successful upload is submission evidence. Check Marketplace verification
+status and Open VSX public availability separately after the first release run.

{crabcode-0.1.8 → crabcode-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: crabcode
-Version: 0.1.8
+Version: 0.1.10
 Summary: CrabCode - AI coding assistant in the terminal
 Requires-Python: >=3.10
 Requires-Dist: anthropic>=0.40.0

{crabcode-0.1.8 → crabcode-0.1.10}/README.md

@@ -322,6 +322,18 @@ plans, diffs, and checkpoint recovery. Tauri additionally provides system
 credential storage and automatic local Gateway startup; browser mode connects
 to an already-running Gateway and retains passwords only for the current tab.
 
+Local Desktop startup requires Python 3.10–3.14 (the current Gateway dependencies
+do not support Python 3.15). On Windows, Desktop checks
+the configured Python path and PATH commands, then registered Python installations,
+uv (including `UV_PYTHON_INSTALL_DIR`), standard installation folders, and common
+Conda locations. Python does not need to be on PATH; Microsoft Store placeholders
+and unusable interpreters are skipped. You can also set an executable explicitly
+under **Settings → General → Python path**. Desktop installs its backend into a
+separate environment when needed; it does not install Python itself.
+The VS Code extension uses the same additional Windows discovery sources after
+checking its configured interpreter, Python extension, workspace `.venv`, Conda,
+and PATH. Set `crabcode.pythonPath` to select a particular installation.
+
 Downloadable Desktop DMG/MSI installers and platform/universal VSIXs are built
 through **Actions → Client Packages → Run workflow**. See
 [manual client packaging](CLIENT_PACKAGING.md) for downloads and signing.
@@ -580,7 +592,7 @@ For DeepSeek V4 thinking mode with tool calls, enable reasoning pass-through:
 
 CrabCode automatically manages the context window to prevent `400 token limit exceeded` errors.
 
-When importing new models with **Get model list** on a configuration group in Desktop or VS Code, CrabCode saves context and output limits supplied by `/models`. It recognizes Anthropic's `max_input_tokens` / `max_tokens`, OpenRouter's `context_length` / `top_provider.max_completion_tokens`, and common compatible API limit fields, using the smaller limit when several are present. Explicit thinking capability metadata configures the thinking switch; Anthropic thinking budgets are kept below the output limit. Explicit group context overrides, smaller output budgets, and disabled thinking are preserved. Existing model profiles are untouched, and missing metadata continues to inherit settings or use runtime defaults. Temperature, reasoning effort, prices, and image/tool capabilities are not inferred from model names or automatically changed.
+When importing new models with **Get model list** on a configuration group in Desktop or VS Code, or with `/add discover` in the CLI, CrabCode saves context and output limits supplied by `/models`. It recognizes Anthropic's `max_input_tokens` / `max_tokens`, OpenRouter's `context_length` / `top_provider.max_completion_tokens`, and common compatible API limit fields, using the smaller limit when several are present. Explicit thinking capability metadata configures the thinking switch; Anthropic thinking budgets are kept below the output limit. Explicit group context overrides, smaller output budgets, and disabled thinking are preserved. Existing model profiles are untouched, and missing metadata continues to inherit settings or use runtime defaults. Temperature, reasoning effort, prices, and image/tool capabilities are not inferred from model names or automatically changed.
 
 **How context window size is resolved** (in priority order):
 
@@ -766,8 +778,9 @@ crabcode --model-profile smart    # short: -M smart
 /model fast         # switch to the "fast" (ollama) profile
 /model smart        # switch to the "smart" (anthropic) profile
 /model code         # switch to the "code" (openai) profile
-/add                # guided menu: add a model or shared group
+/add                # guided menu: add a model/group or fetch models from a group
 /add model          # open the add-model wizard directly
+/add discover       # fetch and batch-import models from an existing group
 /del group          # choose and delete a group definition
 ```
 
@@ -775,6 +788,13 @@ Switching does not clear conversation history — you can mix models freely with
 The `/add` and `/del` wizards let you choose user, shared-project, or local-project
 settings. Delete targets show their exact source layer; the active model (or its
 group) is protected until you switch away from it.
+Use `/add discover` (or **Get models from group** in `/add`) to fetch the same
+model list available in Desktop. Choose a saved group, type to search, use
+Space/Tab to toggle models and Ctrl+A to toggle all search results, then press
+Enter to choose the destination settings layer and confirm the import. Each batch
+supports up to 1000 models. Existing models and defaults are preserved; new
+profiles inherit the group's connection settings and use API-provided metadata
+for context, output and thinking limits. Use `/model` to switch after importing.
 
 ## Built-in Tools
 
@@ -1156,7 +1176,7 @@ never modified by either client.
 | `/logs --clear <name>` | Clear a specific log file |
 | `/model` | Open a searchable model picker organized by group; ↑/↓ select, Enter switches, Esc cancels, Tab and ←/→ filter groups |
 | `/model <name>` | Switch to a named model from `settings.models` |
-| `/add [model\|group]` | Add a named model or shared group with a guided, searchable configuration wizard |
+| `/add [model\|group\|discover]` | Add a model/group or fetch, select and batch-import models from an existing group |
 | `/del [model\|group]` | Delete a model or group from a selected writable settings layer |
 | `/effort` | Show the active reasoning effort |
 | `/effort <none\|minimal\|low\|medium\|high\|xhigh\|max>` | Set reasoning effort for subsequent requests in the current runtime session |

{crabcode-0.1.8 → crabcode-0.1.10}/README.zh-CN.md

@@ -319,6 +319,15 @@ Gateway 允许工作区内的 `cwd`。
 Tauri 额外提供系统凭据库与本地 Gateway 自动启动；浏览器版连接已经运行的
 Gateway，密码只保留在当前浏览器标签页中。
 
+Desktop 启动本地服务需要 Python 3.10–3.14（当前网关依赖尚不支持 Python 3.15）。
+Windows 版会依次检查指定的
+Python 路径、PATH 命令、注册表中的 Python、uv（包括 `UV_PYTHON_INSTALL_DIR`）、
+常见安装目录和 Conda 目录。Python 不必加入 PATH；商店占位程序和无法运行的
+解释器会被跳过。也可以在**设置 → 常规 → Python 路径**中手动指定可执行文件。
+需要时 Desktop 会在独立环境中安装后端依赖，但不会自动安装 Python 本身。
+VS Code 扩展在指定解释器、Python 扩展、工作区 `.venv`、Conda 和 PATH 都不可用时，
+也会搜索上述 Windows 安装位置；可通过 `crabcode.pythonPath` 指定要使用的解释器。
+
 Desktop 和 VS Code 扩展中的每条已完成助手回复都可以分叉到新会话。新会话会
 立即打开，保留该回复之前的对话，并显示来源会话/标题；运行中的轮次、待处理的
 工具、权限请求和 WebSocket 运行态不会被复制。VS Code 聊天里的复制按钮默认隐藏，
@@ -569,7 +578,7 @@ DeepSeek V4 思考模式配合工具调用时，需要开启 reasoning 回传：
 
 CrabCode 会自动管理上下文窗口，防止因 token 超限导致 `400` 报错。
 
-在 Desktop 或 VS Code 的模型设置中，从配置组「获取模型列表」并导入新模型时，会自动保存 `/models` 返回的上下文窗口和最大输出 token 数。支持 Anthropic 的 `max_input_tokens` / `max_tokens`、OpenRouter 的 `context_length` / `top_provider.max_completion_tokens`，以及兼容接口的常见限制字段；有多项限制时取较小值。接口明确提供思考能力时会设置思考开关，Anthropic 的思考预算也会限制在输出上限以内。配置组中手动指定的上下文窗口、较小的输出预算和关闭思考的偏好会保留；已有模型不会被覆盖，接口未提供的字段继续继承配置或使用运行时默认值。温度、思考强度、价格和图像/工具能力不会根据模型名称推测或自动改写。
+在 Desktop 或 VS Code 的模型设置中从配置组「获取模型列表」，或在 CLI 中使用 `/add discover` 导入新模型时，会自动保存 `/models` 返回的上下文窗口和最大输出 token 数。支持 Anthropic 的 `max_input_tokens` / `max_tokens`、OpenRouter 的 `context_length` / `top_provider.max_completion_tokens`，以及兼容接口的常见限制字段；有多项限制时取较小值。接口明确提供思考能力时会设置思考开关，Anthropic 的思考预算也会限制在输出上限以内。配置组中手动指定的上下文窗口、较小的输出预算和关闭思考的偏好会保留；已有模型不会被覆盖，接口未提供的字段继续继承配置或使用运行时默认值。温度、思考强度、价格和图像/工具能力不会根据模型名称推测或自动改写。
 
 **上下文窗口大小的解析优先级：**
 
@@ -749,14 +758,20 @@ crabcode --model-profile smart    # 简写：-M smart
 /model              # 打开模型选择页，搜索并切换已配置的模型
 /model fast         # 切换到 "fast" 模型
 /model local        # 切换到 "local"（如 Ollama 本地模型）
-/add                # 进入引导菜单，添加模型或共享 group
+/add                # 进入引导菜单，添加模型/group 或从 group 获取模型
 /add model          # 直接进入添加模型向导
+/add discover       # 从已有 group 获取模型列表并批量导入
 /del group          # 选择并删除一个 group 定义
 ```
 
 切换模型不会清空对话历史，可以在同一会话中混用不同模型。
 `/add` 与 `/del` 向导可选择用户级、项目共享或项目本地配置层；删除列表会
 明确显示定义所在层。当前正在使用的模型及其 group 需先切换后才能删除。
+使用 `/add discover`（或 `/add` 菜单中的 **Get models from group**）可获取与
+Desktop 相同的模型列表。选定已有 group 后，输入文字搜索，按空格或 Tab 勾选，
+Ctrl+A 全选/取消当前搜索结果，再按 Enter 选择保存层并确认导入；每批最多 1000 个。
+已有模型和默认模型保持不变，新模型继承 group 的连接配置，并应用接口提供的
+上下文、输出和思考限制。导入后可用 `/model` 切换。
 
 ## 内置工具
 
@@ -1141,7 +1156,7 @@ Desktop 的“设置 → 运行与工具”可以直接编辑这些字段，也
 | `/logs --clear <名称>` | 清空指定日志文件 |
 | `/model` | 打开按分组展示、可搜索的模型选择页；↑/↓ 选择、Enter 切换、Esc 返回，Tab 与 ←/→ 筛选分组 |
 | `/model <名称>` | 切换到 `settings.models` 中的命名模型 |
-| `/add [model\|group]` | 通过可搜索的引导向导添加命名模型或共享 group |
+| `/add [model\|group\|discover]` | 添加模型/group，或从已有 group 获取、选择并批量导入模型 |
 | `/del [model\|group]` | 从指定的可写配置层删除模型或 group |
 | `/effort` | 查看当前 reasoning effort |
 | `/effort <none\|minimal\|low\|medium\|high\|xhigh\|max>` | 设置当前运行会话后续请求的 reasoning effort |

{crabcode-0.1.8 → crabcode-0.1.10}/packages/cli/crabcode_cli/model_manager.py

@@ -1,4 +1,4 @@
-"""Guided terminal menus for adding and deleting model catalog entries."""
+"""Guided terminal menus for adding, discovering and deleting models."""
 
 from __future__ import annotations
 
@@ -16,17 +16,20 @@ from prompt_toolkit.layout import HSplit, Layout, VSplit, Window
 from prompt_toolkit.layout.controls import BufferControl, FormattedTextControl
 
 from crabcode_cli.session_picker import PICKER_STYLE, _plain
+from crabcode_core.api.model_discovery import ModelDiscoveryError, discover_models
 from crabcode_core.config.manager import ConfigManager
 from crabcode_core.config.model_catalog import (
     SETTINGS_SOURCE_LABELS,
     WRITABLE_SETTINGS_SOURCES,
     CatalogKind,
+    CatalogImportResult,
     CatalogMutationResult,
     ModelCatalogError,
     WritableSettingsSource,
     add_catalog_entry,
     catalog_names,
     delete_catalog_entry,
+    import_group_models,
     list_catalog_definitions,
     referencing_models,
     settings_source_path,
@@ -36,6 +39,7 @@ from crabcode_core.events import CoreSession
 
 
 ManagementAction = Literal["add", "delete"]
+ManagementKind = Literal["model", "group", "discover"]
 
 _SENSITIVE_CONFIG_KEYS = (
     "api_key",
@@ -53,6 +57,7 @@ class MenuOption:
     value: str
     label: str
     hint: str = ""
+    disabled: bool = False
 
 
 class Prompter(Protocol):
@@ -65,6 +70,10 @@ class Prompter(Protocol):
         initial: str | None = None,
     ) -> str | None: ...
 
+    async def multiselect(
+        self, message: str, options: Sequence[MenuOption],
+    ) -> list[str] | None: ...
+
     async def text(self, message: str, *, initial: str = "") -> str | None: ...
 
     async def confirm(self, message: str, *, default: bool = False) -> bool | None: ...
@@ -85,12 +94,16 @@ class SearchableMenu:
         *,
         searchable: bool = True,
         initial: str | None = None,
+        multiple: bool = False,
     ) -> None:
         self.title = title
         self.message = message
         self.options = list(options)
         self.searchable = searchable
         self.initial = initial
+        self.multiple = multiple
+        self.checked: set[str] = set()
+        self.selection_error = ""
         self.matches = self.options.copy()
         self.selected = next(
             (index for index, option in enumerate(self.matches) if option.value == initial),
@@ -118,9 +131,39 @@ class SearchableMenu:
 
         @bindings.add("enter", eager=True)
         def confirm(event: Any) -> None:
-            if self.matches:
+            if self.multiple:
+                if self.checked:
+                    event.app.exit(result=[option.value for option in self.options if option.value in self.checked])
+            elif self.matches:
                 event.app.exit(result=self.matches[self.selected].value)
 
+        if multiple:
+            @bindings.add("tab", eager=True)
+            @bindings.add(" ", eager=True)
+            def toggle(event: Any) -> None:
+                if self.matches:
+                    option = self.matches[self.selected]
+                    if option.disabled:
+                        return
+                    self.selection_error = ""
+                    if option.value in self.checked:
+                        self.checked.remove(option.value)
+                    elif len(self.checked) < 1000:
+                        self.checked.add(option.value)
+                    else:
+                        self.selection_error = "Select at most 1000 models per import."
+
+            @bindings.add("c-a", eager=True)
+            def toggle_visible(event: Any) -> None:
+                visible = {option.value for option in self.matches if not option.disabled}
+                self.selection_error = ""
+                if visible <= self.checked:
+                    self.checked.difference_update(visible)
+                elif len(self.checked | visible) <= 1000:
+                    self.checked.update(visible)
+                else:
+                    self.selection_error = "Select at most 1000 models; narrow the search first."
+
         @bindings.add("up")
         @bindings.add("down")
         @bindings.add("pageup")
@@ -172,11 +215,11 @@ class SearchableMenu:
                 self.list_window,
                 Window(FormattedTextControl(self._details), height=2, wrap_lines=True),
                 Window(char="─", height=1, style="class:hint"),
-                Window(FormattedTextControl(self._footer), height=2, wrap_lines=True),
+                Window(FormattedTextControl(self._footer), height=3 if multiple else 2, wrap_lines=True),
             ]
         )
         focused = self.search if searchable else self.list_control
-        self.app: Application[str | None] = Application(
+        self.app: Application[str | list[str] | None] = Application(
             layout=Layout(HSplit(content), focused_element=focused),
             key_bindings=bindings,
             full_screen=True,
@@ -218,10 +261,13 @@ class SearchableMenu:
         fragments: list[tuple[str, str]] = []
         for index, option in enumerate(self.matches):
             style = "class:selected" if index == self.selected else ""
+            marker = ""
+            if self.multiple:
+                marker = "[✓] " if option.disabled else "[x] " if option.value in self.checked else "[ ] "
             fragments.extend(
                 [
                     (style, "  ❯ " if index == self.selected else "    "),
-                    (style, _plain(option.label)),
+                    (style, marker + _plain(option.label)),
                     ("", "\n" if index < len(self.matches) - 1 else ""),
                 ]
             )
@@ -237,6 +283,12 @@ class SearchableMenu:
 
     def _footer(self) -> list[tuple[str, str]]:
         count = len(self.matches)
+        if self.multiple:
+            return [("class:hint",
+                "  ↑↓ browse · Space/Tab toggle · Enter import · Esc cancel\n"
+                "  Ctrl+A toggle results · Type to search · Ctrl+U clear\n"
+                f"  {self.selection_error or f'{len(self.checked)} selected · {count} shown'}"
+            )]
         search_help = " · Type to search" if self.searchable else ""
         return [
             (
@@ -246,7 +298,7 @@ class SearchableMenu:
             )
         ]
 
-    async def run(self) -> str | None:
+    async def run(self) -> str | list[str] | None:
         if not self.options:
             return None
         return await self.app.run_async()
@@ -264,13 +316,22 @@ class TerminalPrompter:
         searchable: bool = True,
         initial: str | None = None,
     ) -> str | None:
-        return await SearchableMenu(
+        result = await SearchableMenu(
             "Model management",
             message,
             options,
             searchable=searchable,
             initial=initial,
         ).run()
+        return cast(str | None, result)
+
+    async def multiselect(
+        self, message: str, options: Sequence[MenuOption],
+    ) -> list[str] | None:
+        result = await SearchableMenu(
+            "Get models from group", message, options, multiple=True,
+        ).run()
+        return cast(list[str] | None, result)
 
     async def text(self, message: str, *, initial: str = "") -> str | None:
         prompt: PromptSession[str] = PromptSession()
@@ -337,17 +398,21 @@ _FORMATS: tuple[MenuOption, ...] = tuple(
 async def manage_model_catalog(
     session: CoreSession,
     action: ManagementAction,
-    kind: CatalogKind | None = None,
+    kind: ManagementKind | None = None,
     *,
     prompter: Prompter | None = None,
-) -> CatalogMutationResult | None:
-    """Run the guided add/delete flow and refresh the current session catalog."""
+) -> CatalogMutationResult | CatalogImportResult | None:
+    """Run the guided management flow and refresh the current session catalog."""
     active_prompter = prompter or TerminalPrompter()
     try:
         selected_kind = kind or await _choose_kind(action, active_prompter)
         if selected_kind is None:
             return None
-        if action == "add":
+        if selected_kind == "discover":
+            if action != "add":
+                raise ModelCatalogError("Use /add discover to fetch models from a group.")
+            result = await _discover_group_models(session, active_prompter)
+        elif action == "add":
             result = await _add_entry(session, selected_kind, active_prompter)
         else:
             result = await _delete_entry(session, selected_kind, active_prompter)
@@ -358,17 +423,74 @@ async def manage_model_catalog(
         return None
 
 
-async def _choose_kind(action: ManagementAction, prompter: Prompter) -> CatalogKind | None:
+async def _choose_kind(action: ManagementAction, prompter: Prompter) -> ManagementKind | None:
+    options = [
+        MenuOption("model", "Model", "A named model profile shown by /model"),
+        MenuOption("group", "Group", "Shared provider and API settings inherited by models"),
+    ]
+    if action == "add":
+        options.append(MenuOption("discover", "Get models from group", "Fetch, search and import models using a saved group"))
     value = await prompter.select(
         "What do you want to add?" if action == "add" else "What do you want to delete?",
-        (
-            MenuOption("model", "Model", "A named model profile shown by /model"),
-            MenuOption("group", "Group", "Shared provider and API settings inherited by models"),
-        ),
+        options,
         searchable=False,
         initial="model",
     )
-    return cast(CatalogKind | None, value)
+    return cast(ManagementKind | None, value)
+
+
+async def _discover_group_models(
+    session: CoreSession, prompter: Prompter,
+) -> CatalogImportResult | None:
+    settings = ConfigManager(cwd=session.cwd).load()
+    if not settings.groups:
+        raise ModelCatalogError("No configuration groups found. Create one with /add group first.")
+    name = await prompter.select(
+        "Select a group to fetch models from",
+        [MenuOption(name, name, _config_hint(group.model_dump(exclude_none=True)))
+         for name, group in settings.groups.items()],
+    )
+    if name is None:
+        return None
+    prompter.note("Fetching model list", f"Group: {_plain(name)} · timeout: 15 seconds")
+    try:
+        models = await discover_models(settings.groups[name], settings.env)
+    except ModelDiscoveryError as exc:
+        raise ModelCatalogError(str(exc)) from None
+    existing_ids = {config.model for config in settings.models.values() if config.group == name}
+    available = [model for model in models if model["id"] not in existing_ids]
+    if not available:
+        prompter.note("Model list", "All returned models are already in this group." if models else "The API returned no models.")
+        return None
+    options = []
+    for model in models:
+        existing = model["id"] in existing_ids
+        metadata = model.get("config", {})
+        hints = [model.get("name", "")]
+        hints.extend(f"{key}: {value}" for key, value in metadata.items())
+        options.append(MenuOption(
+            model["id"], model["id"] + (" · already added" if existing else ""),
+            " · ".join(hint for hint in hints if hint), disabled=existing,
+        ))
+    selected = await prompter.multiselect(f"Group: {name} · select models to import", options)
+    if not selected:
+        return None
+    selected_ids = set(selected)
+    if not selected_ids <= {model["id"] for model in available}:
+        raise ModelCatalogError("Select only available models from the fetched list.")
+    source = await _choose_source(session.cwd, prompter)
+    preview = "\n".join(_plain(model_id) for model_id in selected[:20])
+    if len(selected) > 20:
+        preview += f"\n… and {len(selected) - 20} more"
+    prompter.note(
+        f'Import {len(selected)} models from "{_plain(name)}" into {SETTINGS_SOURCE_LABELS[source]}', preview,
+    )
+    if not await prompter.confirm("Import selected models?", default=True):
+        return None
+    return import_group_models(
+        session.cwd, source, name, selected,
+        {model["id"]: model["config"] for model in models if model["id"] in selected_ids and model.get("config")},
+    )
 
 
 async def _choose_source(cwd: str, prompter: Prompter) -> WritableSettingsSource: