pilotswarm 0.5.15 → 0.5.16

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pilotswarm",
-    "version": "0.5.15",
+    "version": "0.5.16",
     "description": "PilotSwarm application package: terminal UI, browser portal + Web API server, and MCP server — one install, three bins.",
     "type": "module",
     "license": "MIT",
@@ -78,7 +78,7 @@
         "hono": "^4.12.10",
         "ink": "^6.8.0",
         "jose": "^6.2.2",
-        "pilotswarm-sdk": "^0.5.15",
+        "pilotswarm-sdk": "^0.5.16",
         "react": "^19.2.4",
         "react-dom": "^19.2.4",
         "ws": "^8.18.2"

package/tui/plugins/.mcp.json

@@ -1 +1,7 @@
-{}
+{
+  "deepwiki": {
+    "type": "http",
+    "url": "https://mcp.deepwiki.com/mcp",
+    "tools": ["*"]
+  }
+}

package/tui/plugins/agents/deepwiki.agent.md

@@ -0,0 +1,44 @@
+---
+schemaVersion: 2
+version: 1.0.0
+name: deepwiki
+title: DeepWiki Code Explorer
+description: Answers questions about any public GitHub repository using the DeepWiki MCP server. Loads ONLY the DeepWiki MCP — no other servers — demonstrating per-agent MCP scoping.
+mcpServers:
+  - deepwiki
+inheritDefaultMcpServers: false
+initialPrompt: >
+  Introduce yourself as the DeepWiki Code Explorer. Ask the user which public
+  GitHub repository (owner/repo) they want to explore and what they want to know.
+---
+
+# DeepWiki Code Explorer
+
+You answer questions about **public GitHub codebases** using the **DeepWiki**
+MCP server — the only MCP server available to you. DeepWiki serves
+AI-generated documentation grounded in a repository's code.
+
+Your DeepWiki tools:
+- `read_wiki_structure` — list the documentation topics/sections for a repo.
+- `read_wiki_contents` — read the full generated documentation for a repo.
+- `ask_question` — ask a natural-language question about a repo and get an
+  answer grounded in its code and docs.
+
+All of these take a repository as `owner/repo` (for example `facebook/react`).
+
+How to work:
+1. Identify the target repository as `owner/repo`. If the user names a project
+   without the owner, or it's ambiguous, ask which `owner/repo` they mean
+   before calling a tool.
+2. For a specific question, prefer `ask_question`. For an overview or to find
+   the right area first, start with `read_wiki_structure`, then drill in with
+   `read_wiki_contents` or `ask_question`.
+3. Ground every answer in what DeepWiki returns and name the repo (and the
+   topic/section) you drew from. If DeepWiki has no coverage for a repo, say so
+   plainly instead of guessing.
+4. Keep answers focused and technical; quote identifiers and file/module names
+   when they help.
+
+You have no web browsing and cannot clone or read repositories directly —
+everything comes through the DeepWiki MCP server. If a question can't be
+answered from DeepWiki, say what's missing.

package/tui/src/node-sdk-transport.js

@@ -1037,8 +1037,20 @@ export class NodeSdkTransport {
             : null;
         if (profile?.githubCopilotKeySet === true) return effectiveModel;
 
-        throw new Error(
-            "GitHub Copilot key not configured. Set GITHUB_TOKEN on the worker or set your per-user GitHub Copilot key in Admin before creating GitHub Copilot model sessions.",
+        // The caller never picked this Copilot model — it came from the
+        // catalog default. Fall back to the first non-Copilot model instead
+        // of failing a session the user has no key for.
+        if (!model && typeof this.mgmt.listModels === "function") {
+            const fallback = (this.mgmt.listModels() || [])
+                .find((entry) => entry?.providerType !== "github" && entry?.qualifiedName);
+            if (fallback) return fallback.qualifiedName;
+        }
+
+        throw Object.assign(
+            new Error(
+                "GitHub Copilot key missing or invalid. Set GITHUB_TOKEN on the worker or configure your per-user GitHub Copilot key in Admin before using GitHub Copilot models.",
+            ),
+            { code: "GHCP_KEY_MISSING", status: 400 },
         );
     }
 

package/ui/core/src/controller.js

@@ -216,6 +216,22 @@ const CONTEXT_TIER_LABELS = {
     long_context: "Long context (larger window, higher cost)",
 };
 
+function formatContextWindowSize(value) {
+    const tokens = Number(value);
+    if (!Number.isSafeInteger(tokens) || tokens <= 0) return null;
+    if (tokens % 1_000_000 === 0) return `${tokens / 1_000_000}M`;
+    if (tokens % 1_000 === 0) return `${tokens / 1_000}K`;
+    return tokens.toLocaleString("en-US");
+}
+
+function formatContextTierLabel(tier, tokenLimit) {
+    const size = formatContextWindowSize(tokenLimit);
+    if (!size) return CONTEXT_TIER_LABELS[tier] || tier;
+    return tier === "long_context"
+        ? `Long context (${size} tokens, higher cost)`
+        : `Default (${size} tokens)`;
+}
+
 function extractSessionModelFromEvents(events = []) {
     // Only explicit model-change events may update the session's model.
     // Deriving it from any event that happens to carry a `model` field lets
@@ -1103,6 +1119,7 @@ export class PilotSwarmUiController {
             text: String(prompt || ""),
             createdAt: Date.now(),
             phase: normalizedPhase,
+            attempted: false,
             clientMessageIds: [id],
         };
     }
@@ -1122,9 +1139,9 @@ export class PilotSwarmUiController {
     }
 
     getEditableOutboxItems(sessionId) {
-        // Only pending items are editable/cancelable on the client; queued items
-        // are durable and need a durable cancel API to remove.
-        return this.getPendingOutboxItems(sessionId);
+        // Attempted envelopes are immutable because the server may already
+        // have accepted their IDs even when the client saw a transport error.
+        return this.getPendingOutboxItems(sessionId).filter((item) => item?.attempted !== true);
     }
 
     getPromptEditSessionMatch(sessionId = this.getState().sessions.activeSessionId) {
@@ -1412,7 +1429,11 @@ export class PilotSwarmUiController {
             return false;
         }
 
-        const pendingItems = this.getPendingOutboxItems(sessionId);
+        const allPendingItems = this.getPendingOutboxItems(sessionId);
+        const attemptedItem = allPendingItems.find((item) => item?.attempted === true);
+        const pendingItems = attemptedItem
+            ? [attemptedItem]
+            : allPendingItems.filter((item) => item?.attempted !== true);
         if (pendingItems.length === 0) return false;
 
         // Merge all current pending items into a single durable envelope.
@@ -1430,6 +1451,7 @@ export class PilotSwarmUiController {
             text: mergedText,
             createdAt: pendingItems[0].createdAt || Date.now(),
             phase: "pending",
+            attempted: true,
             clientMessageIds: mergedClientMessageIds,
         };
         const pendingIdSet = new Set(pendingItems.map((item) => item.id));
@@ -1480,10 +1502,11 @@ export class PilotSwarmUiController {
                     }
                 }, 6000);
             } else {
-                // Transient failure: revert the merged envelope back to the
-                // original pending items so the user can edit/retry them.
-                const reverted = items.flatMap((item) => (
-                    item.id === mergedItem.id ? pendingItems : [item]
+                // Transient failure: preserve the exact attempted envelope.
+                // Re-merging it with fresh messages could make server-side
+                // duplicate suppression drop the fresh content too.
+                const reverted = items.map((item) => (
+                    item.id === mergedItem.id ? { ...mergedItem, phase: "pending", attempted: true } : item
                 ));
                 this.setSessionOutboxItems(sessionId, reverted);
             }
@@ -3763,7 +3786,8 @@ export class PilotSwarmUiController {
         const items = supported.map((tier) => ({
             id: tier,
             tier,
-            label: CONTEXT_TIER_LABELS[tier] || tier,
+            tokenLimit: modelItem?.contextWindowSizes?.[tier] || null,
+            label: formatContextTierLabel(tier, modelItem?.contextWindowSizes?.[tier]),
             isDefault: selectedTier === tier,
         }));
         const selectedIndex = Math.max(0, items.findIndex((item) => item.id === selectedTier));
@@ -3800,25 +3824,38 @@ export class PilotSwarmUiController {
         const groupedModels = typeof this.transport.getModelsByProvider === "function"
             ? this.transport.getModelsByProvider()
             : groupModelsByProvider(models);
+        // Whether the current user has a per-user GitHub Copilot key:
+        // true/false when known, null when the transport can't tell (then
+        // no model gets disabled — never lock models out on a guess).
+        const ghcpUserKeySet = await this._resolveGhcpUserKeySet();
         const items = [];
         const groups = groupedModels
             .map((group) => ({
                 providerId: group.providerId,
                 providerType: group.type || group.providerType,
                 models: (group.models || []).map((model) => {
+                    const providerType = model.providerType || group.type || group.providerType;
+                    // Copilot models with no worker-level token are unusable
+                    // for users who haven't stored their own GitHub key.
+                    const ghcpKeyMissing = providerType === "github"
+                        && model.credentialAvailable === false
+                        && ghcpUserKeySet === false;
                     const item = {
                         id: model.qualifiedName,
                         qualifiedName: model.qualifiedName,
                         modelName: model.modelName || model.qualifiedName,
                         providerId: model.providerId || group.providerId,
-                        providerType: model.providerType || group.type || group.providerType,
+                        providerType,
                         description: model.description || "",
                         cost: model.cost || null,
                         supportedReasoningEfforts: normalizeReasoningEfforts(model.supportedReasoningEfforts),
                         defaultReasoningEffort: model.defaultReasoningEffort || null,
                         supportedContextTiers: normalizeContextTiers(model.supportedContextTiers),
                         defaultContextTier: model.defaultContextTier || null,
+                        contextWindowSizes: model.contextWindowSizes || null,
                         isDefault: defaultModel === model.qualifiedName,
+                        ghcpKeyMissing,
+                        disabled: ghcpKeyMissing,
                     };
                     items.push(item);
                     return item;
@@ -3827,7 +3864,12 @@ export class PilotSwarmUiController {
             .filter((group) => group.models.length > 0);
 
         const preferredModel = sessionOptions?.model || defaultModel;
-        const selectedIndex = Math.max(0, items.findIndex((model) => model.qualifiedName === preferredModel));
+        // Never preselect a key-blocked Copilot model: when the preferred
+        // model (often the catalog default) is unusable, land on the first
+        // usable model instead.
+        let selectedIndex = items.findIndex((model) => model.qualifiedName === preferredModel && !model.disabled);
+        if (selectedIndex < 0) selectedIndex = items.findIndex((model) => !model.disabled);
+        if (selectedIndex < 0) selectedIndex = 0;
         this.dispatch({
             type: "ui/modal",
             modal: {
@@ -3843,6 +3885,27 @@ export class PilotSwarmUiController {
         this.dispatch({ type: "ui/status", text: "Select a model and press Enter" });
     }
 
+    async _resolveGhcpUserKeySet() {
+        // Freshest signal first: the profile the Admin console loaded in this
+        // session (updates immediately after the user saves a key there).
+        const adminProfile = this.getState().admin?.profile;
+        if (typeof adminProfile?.githubCopilotKeySet === "boolean") {
+            return adminProfile.githubCopilotKeySet;
+        }
+        if (typeof this.transport.getCurrentUserProfile !== "function") return null;
+        try {
+            const profile = await this.transport.getCurrentUserProfile();
+            if (profile && typeof profile.githubCopilotKeySet === "boolean") {
+                return profile.githubCopilotKeySet;
+            }
+            // Profile fetch succeeded but no stored flag — a user with no
+            // profile row has no key.
+            return false;
+        } catch {
+            return null;
+        }
+    }
+
     async openSwitchModelPicker(onApplied = null) {
         // Callers (e.g. the portal Manage modal) can be notified when a switch
         // is actually applied — distinct from cancelling the picker — so they
@@ -4903,6 +4966,16 @@ export class PilotSwarmUiController {
         }
         if (modal.type === "modelPicker") {
             const item = modal.items?.[modal.selectedIndex || 0];
+            if (item?.disabled) {
+                // Keep the picker open — the selection is unusable, not wrong.
+                this.dispatch({
+                    type: "ui/status",
+                    text: item.ghcpKeyMissing
+                        ? "This model needs a GitHub Copilot key — add yours in the Admin console first"
+                        : "This model is not available",
+                });
+                return;
+            }
             const previousFocus = modal.previousFocus;
             this.dispatch({ type: "ui/modal", modal: null });
             if (previousFocus) {
@@ -5243,6 +5316,7 @@ export class PilotSwarmUiController {
             const items = this.getSessionOutbox(currentUi.promptEdit.sessionId);
             const nextItems = items.map((item) => (
                 item.id === currentUi.promptEdit.itemId && item.phase === "pending"
+                    && item.attempted !== true
                     ? { ...item, text: nextPrompt }
                     : item
             ));

package/ui/core/src/formatting.js

@@ -992,6 +992,7 @@ export function buildMessageCardLines({
     borderColor = "gray",
     bodyColor = null,
     fitToContent = false,
+    tableMode = null,
 } = {}) {
     const maxWidth = Math.max(fitToContent ? 12 : 20, Number(width) || (fitToContent ? 12 : 20));
     const maxContentWidth = Math.max(1, maxWidth - 4);
@@ -999,6 +1000,30 @@ export function buildMessageCardLines({
         { text: ` ${String(title || "SYSTEM").toUpperCase()} `, color: titleColor, bold: true },
         ...(timestamp ? [{ text: ` ${String(timestamp)} `, color: "gray" }] : []),
     ];
+
+    // Sentinel mode (browser portal): the card is laid out with CSS, so
+    // emit cardStart/cardEnd bounds around the UNWRAPPED markdown body
+    // instead of drawing box art. Hard-wrapping here would mangle
+    // preformatted content (box-drawn tables, ASCII art) that the browser
+    // renders as real HTML tables or scrollable lines.
+    if (tableMode === "sentinel") {
+        const sentinelBodyLines = parseMarkdownLines(String(body || ""), {
+            width: maxContentWidth,
+            tableMode,
+        });
+        const sentinelTinted = bodyColor
+            ? sentinelBodyLines.map((lineRuns) => (Array.isArray(lineRuns)
+                ? recolorRuns(lineRuns, bodyColor)
+                : lineRuns))
+            : sentinelBodyLines;
+        return [
+            { kind: "cardStart", runs: titleRuns, borderColor },
+            ...sentinelTinted,
+            { kind: "cardEnd" },
+            [{ text: "", color: null }],
+        ];
+    }
+
     const bodyLines = parseMarkdownLines(String(body || ""), { width: maxContentWidth });
     const normalizedBodyLines = bodyLines.length > 0
         ? bodyLines.flatMap((lineRuns) => wrapRunsToDisplayWidth(lineRuns, maxContentWidth))

package/ui/core/src/selectors.js

@@ -1923,6 +1923,7 @@ function buildChatMessageLines(message, maxWidth, options = {}) {
                     width: Math.max(20, maxWidth),
                     titleColor: USER_CHAT_COLOR,
                     borderColor: USER_CHAT_COLOR,
+                    tableMode: options.tableMode,
                 }),
                 ...buildChatMessageLines({
                     ...message,
@@ -2000,6 +2001,7 @@ function buildChatMessageLines(message, maxWidth, options = {}) {
             width: Math.max(20, maxWidth),
             titleColor: message?.cardTitleColor || (message?.role === "system" ? "yellow" : "cyan"),
             borderColor: message?.cardBorderColor || "gray",
+            tableMode: options.tableMode,
             ...(isSystemCard ? { bodyColor: "gray", fitToContent: true } : {}),
         });
     }
@@ -3778,7 +3780,7 @@ function buildNodeMapHeaderLine(nodeLabels, colWidth) {
     return runs;
 }
 
-const SEQ_REASONING_EFFORTS = new Set(["low", "medium", "high", "xhigh", "minimal", "none"]);
+const SEQ_REASONING_EFFORTS = new Set(["none", "minimal", "low", "medium", "high", "xhigh", "max"]);
 
 function shortModelForSequence(value) {
     const model = String(value || "").trim();
@@ -4086,10 +4088,12 @@ export function selectModelPickerModal(state, maxWidth = 72) {
                 ? modal.items.findIndex((item) => item.id === model.id)
                 : -1;
             const isSelected = itemIndex === selectedIndex;
+            const isDisabled = Boolean(model.disabled);
             const labelRuns = fitRuns([
                 { text: "· ", color: "gray" },
-                { text: model.modelName || model.qualifiedName || model.id, color: "white", bold: Boolean(model.isDefault) },
+                { text: model.modelName || model.qualifiedName || model.id, color: isDisabled ? "gray" : "white", bold: Boolean(model.isDefault) && !isDisabled },
                 ...(model.cost ? [{ text: ` [${model.cost}]`, color: "gray" }] : []),
+                ...(isDisabled ? [{ text: " ⊘ needs GitHub key", color: "yellow" }] : []),
                 ...(model.isDefault ? [{ text: " ← current default", color: "gray" }] : []),
             ], contentWidth);
 
@@ -4126,6 +4130,9 @@ export function selectModelPickerModal(state, maxWidth = 72) {
                 ? [[{ text: `Reasoning: ${supportedReasoning.join(", ")}`, color: "gray" }]]
                 : []),
             ...(defaultReasoning ? [[{ text: `Default reasoning: ${defaultReasoning}`, color: "gray" }]] : []),
+            ...(selectedItem.disabled
+                ? [[{ text: "Unavailable: requires a GitHub Copilot key. Add yours in the Admin console, then reopen this picker.", color: "yellow" }]]
+                : []),
             [{ text: "", color: "gray" }],
             [{
                 text: selectedItem.description || "No description available for this model.",
@@ -4298,11 +4305,12 @@ export function selectContextTierPickerModal(state, maxWidth = 64) {
 
     const selectedItem = items[selectedIndex] || null;
     const modelItem = modal.modelItem || null;
+    const selectedLabel = selectedItem?.label || selectedItem?.id;
     const detailsLines = [
         [{ text: modelItem?.modelName || modelItem?.qualifiedName || "Selected model", color: "white", bold: true }],
         [{ text: `${modelItem?.providerId || "provider"} (${modelItem?.providerType || "provider"})`, color: "gray" }],
         [{ text: "", color: "gray" }],
-        [{ text: selectedItem?.id ? `Using context window: ${selectedItem.id}` : "Choose a context window.", color: "white" }],
+        [{ text: selectedLabel ? `Using context window: ${selectedLabel}` : "Choose a context window.", color: "white" }],
         [{ text: "Long context costs more per token.", color: "gray" }],
     ];
 

package/ui/react/src/web-app.js

@@ -422,8 +422,9 @@ function normalizeLines(lines) {
             continue;
         }
         // Sentinel kinds preserved as-is so parseStructuredChatBlocks can
-        // recognize and render them (e.g. markdownTable → HTML <table>).
-        if (line?.kind === "markdownTable") {
+        // recognize and render them (e.g. markdownTable → HTML <table>,
+        // cardStart/cardEnd → styled card with structured body).
+        if (line?.kind === "markdownTable" || line?.kind === "cardStart" || line?.kind === "cardEnd") {
             normalized.push(line);
             continue;
         }
@@ -1415,6 +1416,30 @@ function parseStructuredChatBlocks(lines = []) {
             continue;
         }
 
+        // Sentinel card bounds emitted by buildMessageCardLines in sentinel
+        // mode. The body lines between the bounds are UNWRAPPED, so parse
+        // them recursively — box-drawn/markdown tables inside the card
+        // become real HTML tables instead of hard-wrapped box art.
+        if (currentLine?.kind === "cardStart") {
+            const innerLines = [];
+            index += 1;
+            while (index < lines.length && lines[index]?.kind !== "cardEnd") {
+                innerLines.push(lines[index]);
+                index += 1;
+            }
+            if (index < lines.length) index += 1;
+            if (index < lines.length && lineText(lines[index]).trim().length === 0) {
+                index += 1;
+            }
+            blocks.push({
+                type: "card",
+                headerRuns: Array.isArray(currentLine.runs) ? currentLine.runs : [],
+                borderColor: currentLine.borderColor || "gray",
+                blocks: parseStructuredChatBlocks(innerLines),
+            });
+            continue;
+        }
+
         // Sentinel markdown-table line emitted by parseMarkdownLines when
         // tableMode === "sentinel". Carries the raw header + rows so the
         // portal renders a real HTML table with markdown cell content (so
@@ -1563,9 +1588,15 @@ function parseStructuredChatBlocks(lines = []) {
 
 function StructuredChatBlocks({ lines, theme }) {
     const blocks = React.useMemo(() => parseStructuredChatBlocks(lines), [lines]);
+    return React.createElement(StructuredBlockList, { blocks, theme });
+}
 
+// Renders parsed chat blocks; sentinel card blocks recurse through this list
+// so structured content (box/markdown tables, code fences) inside a card
+// renders exactly the same as it does at top level.
+function StructuredBlockList({ blocks, theme }) {
     return React.createElement(React.Fragment, null,
-        blocks.map((block, index) => {
+        (blocks || []).map((block, index) => {
             if (block.type === "preserve") {
                 const variantClass = block.splashVariant ? ` is-splash-${block.splashVariant}` : "";
                 return React.createElement("div", { key: `preserve:${index}`, className: `ps-chat-preserve-block${variantClass}` },
@@ -1593,10 +1624,12 @@ function StructuredChatBlocks({ lines, theme }) {
                 React.createElement("header", { className: "ps-chat-card-header" },
                     React.createElement(Runs, { runs: block.headerRuns, theme })),
                 React.createElement("div", { className: "ps-chat-card-body" },
-                    (block.bodyLines || []).map((bodyRuns, bodyIndex) => React.createElement("div", {
-                        key: `card:${index}:line:${bodyIndex}`,
-                        className: "ps-chat-card-line",
-                    }, React.createElement(Runs, { runs: bodyRuns, theme })) )));
+                    Array.isArray(block.blocks)
+                        ? React.createElement(StructuredBlockList, { blocks: block.blocks, theme })
+                        : (block.bodyLines || []).map((bodyRuns, bodyIndex) => React.createElement("div", {
+                            key: `card:${index}:line:${bodyIndex}`,
+                            className: "ps-chat-card-line",
+                        }, React.createElement(Runs, { runs: bodyRuns, theme })) )));
             }
 
             if (block.type === "table") {
@@ -2193,7 +2226,7 @@ function SessionPane({ controller, actions = null, panelClassName = "", structur
             },
             React.createElement("div", {
                 className: "ps-line ps-session-row-content",
-                style: { paddingInlineStart: `${Math.max(0, row.depth) * 18}px` },
+                style: { paddingInlineStart: `${Math.max(0, row.depth) * 4}px` },
             },
                 React.createElement(SessionRowContent, { row, theme, structured: structuredRows })),
             )),
@@ -4119,7 +4152,7 @@ function ModalLayer({ controller }) {
                 return React.createElement("button", {
                     key: item?.id || `row:${rowIndex}`,
                     type: "button",
-                    className: `ps-list-button ps-modal-list-button${itemIndex === modal.selectedIndex ? " is-selected" : ""}${usesHangingIndent ? " is-hanging" : ""}`,
+                    className: `ps-list-button ps-modal-list-button${itemIndex === modal.selectedIndex ? " is-selected" : ""}${usesHangingIndent ? " is-hanging" : ""}${item?.disabled ? " is-disabled" : ""}`,
                     onClick: () => controller.dispatch({ type: "ui/modalSelection", index: itemIndex }),
                 },
                 React.createElement("div", { className: "ps-line ps-modal-list-line" },
@@ -4128,7 +4161,7 @@ function ModalLayer({ controller }) {
             : (modal.items || []).map((item, index) => React.createElement("button", {
                 key: item.id || index,
                 type: "button",
-                className: `ps-list-button ps-modal-list-button${index === modal.selectedIndex ? " is-selected" : ""}${usesHangingIndent ? " is-hanging" : ""}`,
+                className: `ps-list-button ps-modal-list-button${index === modal.selectedIndex ? " is-selected" : ""}${usesHangingIndent ? " is-hanging" : ""}${item?.disabled ? " is-disabled" : ""}`,
                 onClick: () => controller.dispatch({ type: "ui/modalSelection", index }),
             },
             React.createElement("div", { className: "ps-line ps-modal-list-line" },

package/web/api/router.js

@@ -18,6 +18,8 @@ import { getPublicAuthContext } from "../auth/authz/engine.js";
 
 const ERROR_STATUS_BY_CODE = {
     INVALID_REQUEST: 400,
+    // GitHub Copilot model requested without a worker or per-user key.
+    GHCP_KEY_MISSING: 400,
     PORTAL_AUTH_REQUIRED: 401,
     UNAUTHORIZED: 401,
     FORBIDDEN: 403,
@@ -32,7 +34,7 @@ const ERROR_STATUS_BY_CODE = {
 // messages. These are client errors (their message is the whole value), so
 // they keep their text; everything else that reaches 500 is treated as an
 // unexpected fault and gets a generic message.
-const CLIENT_ERROR_MESSAGE = /must be|is required|cannot be|Unsupported|is not started|terminal orchestration|cannot accept new messages|not found|already|Unknown model|does not support reasoning effort/i;
+const CLIENT_ERROR_MESSAGE = /must be|is required|cannot be|Unsupported|is not started|terminal orchestration|cannot accept new messages|not found|already|Unknown model|does not support reasoning effort|GitHub Copilot key/i;
 
 function statusForError(error) {
     const byCode = ERROR_STATUS_BY_CODE[error?.code];