fengming 0.3.10 → 0.3.12

package/docs/providers/fireworks.md

@@ -1,144 +0,0 @@
----
-summary: "Fireworks setup (auth + model selection)"
-title: "Fireworks"
-read_when:
-  - You want to use Fireworks with FengMing
-  - You need the Fireworks API key env var or default model id
-  - You are debugging Kimi thinking-off behavior on Fireworks
----
-
-[Fireworks](https://fireworks.ai) exposes open-weight and routed models through an OpenAI-compatible API. FengMing includes a bundled Fireworks provider plugin that ships with two pre-cataloged Kimi models and accepts any Fireworks model or router id at runtime.
-
-| Property        | Value                                                  |
-| --------------- | ------------------------------------------------------ |
-| Provider id     | `fireworks` (alias: `fireworks-ai`)                    |
-| Plugin          | bundled, `enabledByDefault: true`                      |
-| Auth env var    | `FIREWORKS_API_KEY`                                    |
-| Onboarding flag | `--auth-choice fireworks-api-key`                      |
-| Direct CLI flag | `--fireworks-api-key <key>`                            |
-| API             | OpenAI-compatible (`openai-completions`)               |
-| Base URL        | `https://api.fireworks.ai/inference/v1`                |
-| Default model   | `fireworks/accounts/fireworks/routers/kimi-k2p5-turbo` |
-| Default alias   | `Kimi K2.5 Turbo`                                      |
-
-## Getting started
-
-<Steps>
-  <Step title="Set the Fireworks API key">
-    <CodeGroup>
-
-```bash Onboarding
-fengming onboard --auth-choice fireworks-api-key
-```
-
-```bash Direct flag
-fengming onboard --non-interactive \
-  --auth-choice fireworks-api-key \
-  --fireworks-api-key "$FIREWORKS_API_KEY"
-```
-
-```bash Env only
-export FIREWORKS_API_KEY=fw-...
-```
-
-    </CodeGroup>
-
-    Onboarding stores the key against the `fireworks` provider in your auth profiles and sets the **Fire Pass** Kimi K2.5 Turbo router as the default model.
-
-  </Step>
-  <Step title="Verify the model is available">
-    ```bash
-    fengming models list --provider fireworks
-    ```
-
-    The list should include `Kimi K2.6` and `Kimi K2.5 Turbo (Fire Pass)`. If `FIREWORKS_API_KEY` is unresolved, `fengming models status --json` reports the missing credential under `auth.unusableProfiles`.
-
-  </Step>
-</Steps>
-
-## Non-interactive setup
-
-For scripted or CI installs, pass everything on the command line:
-
-```bash
-fengming onboard --non-interactive \
-  --mode local \
-  --auth-choice fireworks-api-key \
-  --fireworks-api-key "$FIREWORKS_API_KEY" \
-  --skip-health \
-  --accept-risk
-```
-
-## Built-in catalog
-
-| Model ref                                              | Name                        | Input        | Context | Max output | Thinking             |
-| ------------------------------------------------------ | --------------------------- | ------------ | ------- | ---------- | -------------------- |
-| `fireworks/accounts/fireworks/models/kimi-k2p6`        | Kimi K2.6                   | text + image | 262,144 | 262,144    | Forced off           |
-| `fireworks/accounts/fireworks/routers/kimi-k2p5-turbo` | Kimi K2.5 Turbo (Fire Pass) | text + image | 256,000 | 256,000    | Forced off (default) |
-
-<Note>
-  FengMing pins all Fireworks Kimi models to `thinking: off` because Fireworks rejects Kimi thinking parameters in production. Routing the same model through [Moonshot](/providers/moonshot) directly preserves Kimi reasoning output. See [thinking modes](/tools/thinking) for switching between providers.
-</Note>
-
-## Custom Fireworks model ids
-
-FengMing accepts any Fireworks model or router id at runtime. Use the exact id shown by Fireworks and prefix it with `fireworks/`. Dynamic resolution clones the Fire Pass template (text + image input, OpenAI-compatible API, default cost zero) and disables thinking automatically when the id matches the Kimi pattern. GLM dynamic ids are marked text-only unless you configure a custom model entry with image input.
-
-```json5
-{
-  agents: {
-    defaults: {
-      model: {
-        primary: "fireworks/accounts/fireworks/models/<your-model-id>",
-      },
-    },
-  },
-}
-```
-
-<AccordionGroup>
-  <Accordion title="How model id prefixing works">
-    Every Fireworks model ref in FengMing starts with `fireworks/` followed by the exact id or router path from the Fireworks platform. For example:
-
-    - Router model: `fireworks/accounts/fireworks/routers/kimi-k2p5-turbo`
-    - Direct model: `fireworks/accounts/fireworks/models/<model-name>`
-
-    FengMing strips the `fireworks/` prefix when constructing the API request and sends the remaining path to the Fireworks endpoint as the OpenAI-compatible `model` field.
-
-  </Accordion>
-
-  <Accordion title="Why thinking is forced off for Kimi">
-    Fireworks K2.6 returns a 400 if the request carries `reasoning_*` parameters even though Kimi supports thinking through Moonshot's own API. The bundled policy (`extensions/fireworks/thinking-policy.ts`) advertises only the `off` thinking level for Kimi model ids, so manual `/think` switches and provider-policy surfaces stay aligned with the runtime contract.
-
-    To use Kimi reasoning end-to-end, configure the [Moonshot provider](/providers/moonshot) and route the same model through it.
-
-  </Accordion>
-
-  <Accordion title="Environment availability for the daemon">
-    If the Gateway runs as a managed service (launchd, systemd, Docker), the Fireworks key must be visible to that process — not just to your interactive shell.
-
-    <Warning>
-      A key exported only in an interactive shell will not help a launchd or systemd daemon unless that environment is imported there too. Set the key in `~/.fengming/.env` or via `env.shellEnv` to make it readable from the gateway process.
-    </Warning>
-
-    On macOS, `fengming gateway install` already wires `~/.fengming/.env` into the LaunchAgent environment file. Re-run install (or `fengming doctor --fix`) after rotating the key.
-
-  </Accordion>
-</AccordionGroup>
-
-## Related
-
-<CardGroup cols={2}>
-  <Card title="Model providers" href="/concepts/model-providers" icon="layers">
-    Choosing providers, model refs, and failover behavior.
-  </Card>
-  <Card title="Thinking modes" href="/tools/thinking" icon="brain">
-    `/think` levels, provider policies, and routing reasoning-capable models.
-  </Card>
-  <Card title="Moonshot" href="/providers/moonshot" icon="moon">
-    Run Kimi with native thinking output through Moonshot's own API.
-  </Card>
-  <Card title="Troubleshooting" href="/help/troubleshooting" icon="wrench">
-    General troubleshooting and FAQ.
-  </Card>
-</CardGroup>

package/docs/providers/github-copilot.md

@@ -1,257 +0,0 @@
----
-summary: "Sign in to GitHub Copilot from FengMing using the device flow or non-interactive token import"
-read_when:
-  - You want to use GitHub Copilot as a model provider
-  - You need the `fengming models auth login-github-copilot` flow
-  - You are choosing between the built-in Copilot provider, Copilot SDK harness, and Copilot Proxy
-title: "GitHub Copilot"
----
-
-GitHub Copilot is GitHub's AI coding assistant. It provides access to Copilot
-models for your GitHub account and plan. FengMing can use Copilot as a model
-provider or agent runtime in three different ways.
-
-## Three ways to use Copilot in FengMing
-
-<Tabs>
-  <Tab title="Built-in provider (github-copilot)">
-    Use the native device-login flow to obtain a GitHub token, then exchange it for
-    Copilot API tokens when FengMing runs. This is the **default** and simplest path
-    because it does not require VS Code.
-
-    <Steps>
-      <Step title="Run the login command">
-        ```bash
-        fengming models auth login-github-copilot
-        ```
-
-        You will be prompted to visit a URL and enter a one-time code. Keep the
-        terminal open until it completes.
-      </Step>
-      <Step title="Set a default model">
-        ```bash
-        fengming models set github-copilot/claude-opus-4.7
-        ```
-
-        Or in config:
-
-        ```json5
-        {
-          agents: {
-            defaults: { model: { primary: "github-copilot/claude-opus-4.7" } },
-          },
-        }
-        ```
-      </Step>
-    </Steps>
-
-  </Tab>
-
-  <Tab title="Copilot SDK harness plugin (copilot)">
-    Install the external `@fengming/copilot` plugin when you want GitHub's
-    Copilot CLI and SDK to own the low-level agent loop for selected
-    `github-copilot/*` models.
-
-    ```bash
-    fengming plugins install clawhub:@fengming/copilot
-    ```
-
-    Then opt a model or provider into the runtime:
-
-    ```json5
-    {
-      agents: {
-        defaults: {
-          model: "github-copilot/gpt-5.5",
-          models: {
-            "github-copilot/gpt-5.5": {
-              agentRuntime: { id: "copilot" },
-            },
-          },
-        },
-      },
-    }
-    ```
-
-    Choose this when you want native Copilot CLI sessions, SDK-managed thread
-    state, and Copilot-owned compaction for those agent turns. See
-    [Copilot SDK harness](/plugins/copilot) for the full runtime contract.
-
-  </Tab>
-
-  <Tab title="Copilot Proxy plugin (copilot-proxy)">
-    Use the **Copilot Proxy** VS Code extension as a local bridge. FengMing talks to
-    the proxy's `/v1` endpoint and uses the model list you configure there.
-
-    <Note>
-    Choose this when you already run Copilot Proxy in VS Code or need to route
-    through it. You must enable the plugin and keep the VS Code extension running.
-    </Note>
-
-  </Tab>
-</Tabs>
-
-## Optional flags
-
-| Flag            | Description                                         |
-| --------------- | --------------------------------------------------- |
-| `--yes`         | Skip the confirmation prompt                        |
-| `--set-default` | Also apply the provider's recommended default model |
-
-```bash
-# Skip confirmation
-fengming models auth login-github-copilot --yes
-
-# Login and set the default model in one step
-fengming models auth login --provider github-copilot --method device --set-default
-```
-
-## Non-interactive onboarding
-
-If you already have a GitHub OAuth access token for Copilot, import it during
-headless setup with `fengming onboard --non-interactive`:
-
-```bash
-fengming onboard --non-interactive --accept-risk \
-  --auth-choice github-copilot \
-  --github-copilot-token "$COPILOT_GITHUB_TOKEN" \
-  --skip-channels --skip-health
-```
-
-You can also omit `--auth-choice`; passing `--github-copilot-token` infers the
-GitHub Copilot provider auth choice. If the flag is omitted, onboarding falls
-back to `COPILOT_GITHUB_TOKEN`, `GH_TOKEN`, then `GITHUB_TOKEN`. Use
-`--secret-input-mode ref` with `COPILOT_GITHUB_TOKEN` set to store an env-backed
-`tokenRef` instead of plaintext in `auth-profiles.json`.
-
-<AccordionGroup>
-  <Accordion title="Interactive TTY required">
-    The device-login flow requires an interactive TTY. Run it directly in a
-    terminal, not in a non-interactive script or CI pipeline.
-  </Accordion>
-
-  <Accordion title="Model availability depends on your plan">
-    Copilot model availability depends on your GitHub plan. If a model is
-    rejected, try another ID (for example `github-copilot/gpt-5.5`). See
-    GitHub's [supported models per Copilot plan](https://docs.github.com/en/copilot/reference/ai-models/supported-models#supported-ai-models-per-copilot-plan)
-    for the current model list.
-  </Accordion>
-
-  <Accordion title="Live catalog refresh from the Copilot API">
-    Once the device-login (or env-var) auth path has resolved a GitHub token,
-    FengMing refreshes the model catalog on demand from `${baseUrl}/models`
-    (the same endpoint VS Code Copilot uses) so the runtime tracks
-    per-account entitlement and accurate context windows without manifest
-    churn. Newly published Copilot models become visible without an FengMing
-    upgrade, and context windows reflect the real per-model limits
-    (e.g. 400k for the gpt-5.x series, 1M for the internal
-    `claude-opus-*-1m` variants).
-
-    The bundled static catalog stays as the visible fallback when discovery
-    is disabled, the user has no GitHub auth profile, the token-exchange
-    fails, or the `/models` HTTPS call errors. To opt out and rely entirely
-    on the static manifest catalog (offline / air-gapped scenarios):
-
-    ```json5
-    {
-      plugins: {
-        entries: {
-          "github-copilot": {
-            config: { discovery: { enabled: false } },
-          },
-        },
-      },
-    }
-    ```
-
-  </Accordion>
-
-  <Accordion title="Transport selection">
-    Claude model IDs use the Anthropic Messages transport automatically. GPT,
-    o-series, and Gemini models keep the OpenAI Responses transport. FengMing
-    selects the correct transport based on the model ref.
-  </Accordion>
-
-  <Accordion title="Request compatibility">
-    FengMing sends Copilot IDE-style request headers on Copilot transports,
-    including built-in compaction, tool-result, and image follow-up turns. It
-    does not enable provider-level Responses continuation for Copilot unless
-    that behavior has been verified against Copilot's API.
-  </Accordion>
-
-  <Accordion title="Environment variable resolution order">
-    FengMing resolves Copilot auth from environment variables in the following
-    priority order:
-
-    | Priority | Variable              | Notes                            |
-    | -------- | --------------------- | -------------------------------- |
-    | 1        | `COPILOT_GITHUB_TOKEN` | Highest priority, Copilot-specific |
-    | 2        | `GH_TOKEN`            | GitHub CLI token (fallback)      |
-    | 3        | `GITHUB_TOKEN`        | Standard GitHub token (lowest)   |
-
-    When multiple variables are set, FengMing uses the highest-priority one.
-    The device-login flow (`fengming models auth login-github-copilot`) stores
-    its token in the auth profile store and takes precedence over all environment
-    variables.
-
-  </Accordion>
-
-  <Accordion title="Token storage">
-    The login stores a GitHub token in the auth profile store and exchanges it
-    for a Copilot API token when FengMing runs. You do not need to manage the
-    token manually.
-  </Accordion>
-</AccordionGroup>
-
-<Warning>
-The device-login command requires an interactive TTY. Use non-interactive
-onboarding when you need headless setup.
-</Warning>
-
-## Memory search embeddings
-
-GitHub Copilot can also serve as an embedding provider for
-[memory search](/concepts/memory-search). If you have a Copilot subscription and
-have logged in, FengMing can use it for embeddings without a separate API key.
-
-### Config
-
-Set `memorySearch.provider` explicitly to use GitHub Copilot embeddings. If a
-GitHub token is available, FengMing discovers available embedding models from
-the Copilot API and picks the best one automatically.
-
-```json5
-{
-  agents: {
-    defaults: {
-      memorySearch: {
-        provider: "github-copilot",
-        // Optional: override the auto-discovered model
-        model: "text-embedding-3-small",
-      },
-    },
-  },
-}
-```
-
-### How it works
-
-1. FengMing resolves your GitHub token (from env vars or auth profile).
-2. Exchanges it for a short-lived Copilot API token.
-3. Queries the Copilot `/models` endpoint to discover available embedding models.
-4. Picks the best model (prefers `text-embedding-3-small`).
-5. Sends embedding requests to the Copilot `/embeddings` endpoint.
-
-Model availability depends on your GitHub plan. If no embedding models are
-available, FengMing skips Copilot and tries the next provider.
-
-## Related
-
-<CardGroup cols={2}>
-  <Card title="Model selection" href="/concepts/model-providers" icon="layers">
-    Choosing providers, model refs, and failover behavior.
-  </Card>
-  <Card title="OAuth and auth" href="/gateway/authentication" icon="key">
-    Auth details and credential reuse rules.
-  </Card>
-</CardGroup>

package/docs/providers/gmi.md

@@ -1,92 +0,0 @@
----
-summary: "Use GMI Cloud's OpenAI-compatible API with FengMing"
-read_when:
-  - You want to run FengMing with GMI Cloud models
-  - You need the GMI provider id, key, or endpoint
-title: "GMI Cloud"
----
-
-GMI Cloud is a hosted inference platform for frontier and open-weight models
-behind an OpenAI-compatible API. In FengMing it is a bundled model provider,
-which means you can select it with the provider id `gmi`, store credentials
-through normal model auth, and use model refs like
-`gmi/google/gemini-3.1-flash-lite`.
-
-Use GMI when you want one API key for several hosted model families, including
-Google, Anthropic, OpenAI, DeepSeek, Moonshot, and Z.AI routes exposed by GMI's
-catalog. It is useful as a secondary provider for model fallback, for comparing
-hosted routes across vendors, or when GMI has a model available before your
-primary provider does.
-
-This provider uses OpenAI-compatible chat semantics. FengMing owns the provider
-id, auth profile, aliases, model catalog seed, and base URL; GMI owns the live
-model availability, billing, rate limits, and any provider-side routing policy.
-
-## Setup
-
-Create an API key in GMI Cloud, then run:
-
-```bash
-fengming onboard --auth-choice gmi-api-key
-```
-
-Or set:
-
-```bash
-export GMI_API_KEY="<your-gmi-api-key>" # pragma: allowlist secret
-```
-
-## Defaults
-
-- Provider: `gmi`
-- Aliases: `gmi-cloud`, `gmicloud`
-- Base URL: `https://api.gmi-serving.com/v1`
-- Env var: `GMI_API_KEY`
-- Default model: `gmi/google/gemini-3.1-flash-lite`
-
-## When to choose GMI
-
-- You want a hosted OpenAI-compatible endpoint rather than a local model server.
-- You want to try several commercial and open-weight model families through one
-  provider account.
-- You want a fallback provider with different upstream routing from OpenRouter,
-  DeepInfra, Together, or the direct vendor APIs.
-- You need GMI-specific model ids, pricing, or account controls.
-
-Choose the direct vendor provider instead when you need vendor-native features
-that GMI does not expose through its OpenAI-compatible route. Choose a local
-provider such as Ollama, LM Studio, vLLM, or SGLang when data locality or local
-GPU control matters more than hosted convenience.
-
-## Models
-
-The bundled catalog seeds commonly available GMI Cloud route ids, including:
-
-- `gmi/zai-org/GLM-5.1-FP8`
-- `gmi/deepseek-ai/DeepSeek-V3.2`
-- `gmi/moonshotai/Kimi-K2.5`
-- `gmi/google/gemini-3.1-flash-lite`
-- `gmi/anthropic/claude-sonnet-4.6`
-- `gmi/openai/gpt-5.4`
-
-The catalog is a seed, not a promise that every account can call every model at
-all times. Use FengMing's model listing command to see what the configured
-provider reports in your environment:
-
-```bash
-fengming models list --provider gmi
-```
-
-## Troubleshooting
-
-- `401` or `403`: check that `GMI_API_KEY` is set for the process running
-  FengMing, or re-run onboarding to store the key in the provider auth profile.
-- Unknown model errors: confirm the model exists in your GMI account and use the
-  full `gmi/<route-id>` ref shown by `fengming models list --provider gmi`.
-- Intermittent provider errors: try a different GMI route or configure GMI as a
-  fallback rather than the only primary model provider.
-
-## Related
-
-- [Model providers](/concepts/model-providers)
-- [All providers](/providers/index)