@bubblebrain-ai/bubble 0.0.46 → 0.0.48

package/dist/prompt/reminders.js

@@ -9,12 +9,21 @@
 export function wrapInSystemReminder(content) {
     return content.trim();
 }
+/**
+ * Headlines of the mode reminders below. Identity is content-based because a
+ * reminder is just text once it lands in the message stream; keeping the
+ * headlines in one place stops the matcher from drifting when the bodies are
+ * reworded.
+ */
+const MODE_REMINDER_HEADLINES = [
+    "Plan mode is now ACTIVE",
+    "Permission mode is now: bypassPermissions",
+    "Permission mode is now: default Build mode",
+];
 export function isPermissionModeReminder(content) {
     if (typeof content !== "string")
         return false;
-    return content.includes("Plan mode is now ACTIVE")
-        || content.includes("Permission mode is now: bypassPermissions")
-        || content.includes("Permission mode is now: default Build mode");
+    return MODE_REMINDER_HEADLINES.some((headline) => content.includes(headline));
 }
 const PLAN_MODE_ENTER = `
 Plan mode is now ACTIVE.
@@ -32,6 +41,7 @@ Rules while in plan mode:
 const BYPASS_ENTER = `
 Permission mode is now: bypassPermissions.
 
+This replaces every earlier mode reminder in this conversation. Plan mode is NOT active; exit_plan_mode does not exist in your tool list and must not be called or searched for.
 ALL tool calls auto-approve with no user confirmation. The user has explicitly opted into this.
 Proceed with extra care — explain risky actions in the chat BEFORE performing them, and
 prefer reversible operations when possible.
@@ -40,6 +50,7 @@ Do not perform destructive operations, credential exposure, or unrelated reversi
 const DEFAULT_ENTER = `
 Permission mode is now: default Build mode.
 
+This replaces every earlier mode reminder in this conversation. Plan mode is NOT active; exit_plan_mode does not exist in your tool list and must not be called or searched for.
 File edits and writes auto-approve. Bash commands and other destructive tools still require explicit approval unless allowed by rules.
 Execute the requested change end to end; do not stop at analysis unless blocked or the user explicitly asks for discussion only.
 `;
@@ -72,75 +83,6 @@ export function buildDeferredToolsReminder(names) {
     ];
     return wrapInSystemReminder(lines.join("\n"));
 }
-export function buildInvestigationReminder() {
-    return wrapInSystemReminder(`
-Security/configuration investigation workflow is active.
-
-For this task, gather evidence in this order:
-- locate config load paths
-- locate environment variable reads
-- locate persistent storage paths
-- check whether sensitive values are masked or redacted
-- check whether values can reach logs, client bundles, or user-visible surfaces
-
-Stop once these categories are covered. Do not keep repeating near-identical searches when they are not producing new evidence.
-`);
-}
-export function buildLoopWarningReminder(reason) {
-    return wrapInSystemReminder(`
-Further broad exploration is low value unless there is a concrete remaining evidence gap.
-
-${reason}
-
-Do not repeat near-identical reads or searches unless the path or hypothesis is materially different.
-If current evidence is sufficient, answer with the findings.
-`);
-}
-export function buildSearchFreezeReminder(reason) {
-    return wrapInSystemReminder(`
-Search tools are now constrained for this task.
-
-Reason: ${reason}
-
-Do not continue blind keyword searching. Use the evidence already gathered to reason about the answer.
-You may still read specific files if you already know where the relevant configuration or persistence logic lives.
-`);
-}
-export function buildExplorationFreezeReminder(reason) {
-    return wrapInSystemReminder(`
-Implementation phase has advanced from exploration to modification.
-
-Reason: ${reason}
-
-You have enough context to act. Do not continue reading, searching, or delegating exploration.
-Choose one of:
-1. Use edit/write to make the requested change.
-2. If no safe change can be made from the gathered context, explain the concrete blocker.
-3. If files were already changed, verify the change and run the affected module's existing tests, or finish with the result.
-`);
-}
-export function buildCompletionSelfCheckReminder(options = {}) {
-    const sections = [];
-    const modifiedTests = options.modifiedExistingTests ?? [];
-    if (modifiedTests.length > 0) {
-        // Disclosure, not accusation: legitimate test updates (requirement
-        // changes, fixing a broken test, refactors) are normal engineering — the
-        // rule is that they must be declared, never silent. Confrontational
-        // wording risks a model rolling back a user-requested test update.
-        const listed = modifiedTests
-            .slice(0, 8)
-            .map((t) => `- ${t.path}${t.deletedLines > 0 ? ` (${t.deletedLines} line${t.deletedLines === 1 ? "" : "s"} removed)` : ""}`)
-            .join("\n");
-        sections.push(`This run modified pre-existing test files:
-${listed}${modifiedTests.length > 8 ? `\n- …and ${modifiedTests.length - 8} more` : ""}
-
-If a change you made caused an existing test to fail and you edited the test so the suite passes, restore the original behavior instead — weakening a test to make it pass is never acceptable. If the test changes are intentional (the request requires new expected behavior, or the test itself was wrong), keep them and state each modified test and the reason in your final summary.`);
-    }
-    sections.push(`You appear to be finishing. Before giving your final answer, re-read the user's original request in this conversation and check whether any explicit requirement in it remains unfulfilled — including requirements about how the work should be delivered or reported, not only whether the implementation works.
-
-If something is missing, complete it now. If everything is done, give your final answer directly — do not repeat this check or re-verify work you have already verified.`);
-    return wrapInSystemReminder(`\n${sections.join("\n\n")}\n`);
-}
 export function buildToolFreezeReminder(reason) {
     return wrapInSystemReminder(`
 CRITICAL - MAXIMUM STEPS REACHED
@@ -163,79 +105,31 @@ Response must include:
 Respond with text ONLY.
 `);
 }
-export function buildWorkflowPhaseReminder(input) {
-    const phaseInstructions = {
-        investigate: "Collect direct evidence. Prefer targeted reads and structured searches over blind keyword churn.",
-        correlate: "Stop broad searching. Correlate the evidence you already have and fill only the most specific remaining gaps.",
-        conclude: "You have enough evidence to answer. Do not continue exploring unless you discover a concrete contradiction in the current evidence.",
-    };
-    const covered = input.covered.length > 0 ? input.covered.map((item) => `- ${item}`).join("\n") : "- none yet";
-    const pending = input.pending.length > 0 ? input.pending.map((item) => `- ${item}`).join("\n") : "- none";
-    return wrapInSystemReminder(`
-Workflow phase: ${input.phase}
-
-${phaseInstructions[input.phase]}
-
-Covered evidence:
-${covered}
-
-Remaining evidence to check:
-${pending}
-`);
-}
 // Removed: buildVerificationReminder / buildVerificationFailureReminder.
 // The verification reminder ladder pressured the model to run a "verification"
 // after every file change. For models with hex-tokenization blind spots (e.g.
 // DeepSeek v4-pro), this triggered death loops where the model wrote ad-hoc
 // validation scripts that found the bug but could never fix it. CC trusts the
 // model to decide when verification is meaningful; we follow that.
+// Removed: buildFinalizeOpportunityReminder. Was paired with the verification
+// nag ladder. Without the ladder, "you can finalize now" advice is redundant —
+// the model finalises whenever its own judgement says the task is done.
 /**
- * Fired when a file mutation failure suggests the model may be relying on stale
- * local memory instead of the current file bytes. Models — especially
- * thinking-heavy ones — can otherwise spiral on `No changes made: identical
- * content` or `oldText not found` because their internal reasoning convinces
- * them they are typing the change correctly.
- */
-export function buildEditRetryEscalationReminder(reason) {
-    return wrapInSystemReminder(`
-A file mutation just failed in a way that usually means your local view of the file is stale or the edit anchor is wrong.
-
-${reason}
-
-Stop retrying from memory. Pick one of:
-- Re-read the target file and compare the actual bytes to your intended oldText / newText. Trailing whitespace, unicode lookalikes, or off-by-one boundaries are common causes.
-- If you intended to add a single character (e.g. fixing a 5-digit hex color to 6 digits), confirm that your newText string actually contains the added character before sending again.
-- Use the write tool with the full new content instead of edit — useful when the change spans many lines or the diff anchor is ambiguous.
-- If you cannot determine the cause, ask the user for clarification.
-`);
-}
-/**
- * Fired the FIRST time the model re-reads a file it already read in this turn.
- * Soft — does not freeze the tool. The model may still re-read when context was
- * pruned, the requested range changed, or a later mutation needs verification.
- */
-export function buildRedundantReadReminder(path) {
-    return wrapInSystemReminder(`
-You already read ${path} earlier in this turn. If that content is still available and nothing changed, rely on it rather than re-reading.
-It is okay to re-read when you need to recover pruned context, inspect a different range, or verify a later edit/write/bash change.
-`);
-}
-/**
- * Injected once at task start when the user's input looks like a small,
- * focused task (e.g. "write an HTML page about X"). Counterweight to the
- * default protocol which biases toward thorough exploration.
+ * Modified-existing-tests disclosure (docs/harness-thinning.md): a fact from
+ * git ground truth — bash writes and subagent worktree merges do not appear
+ * in the model's own tool memory. Disclosure, not accusation: legitimate
+ * test updates are normal engineering; the rule is that they must be
+ * declared, never silent.
  */
-export function buildSmallTaskHint() {
+export function buildModifiedTestsDisclosure(modifiedExistingTests) {
+    const listed = modifiedExistingTests
+        .slice(0, 8)
+        .map((t) => `- ${t.path}${t.deletedLines > 0 ? ` (${t.deletedLines} line${t.deletedLines === 1 ? "" : "s"} removed)` : ""}`)
+        .join("\n");
     return wrapInSystemReminder(`
-This appears to be a small, focused task (short request, single deliverable, no integration ambiguity).
+Fact from git: this run modified pre-existing test files:
+${listed}${modifiedExistingTests.length > 8 ? `\n- …and ${modifiedExistingTests.length - 8} more` : ""}
 
-Prefer direct execution over exploration:
-- If the target file path is given or obvious, use write/edit directly.
-- Do not glob, read, or grep adjacent files unless the request explicitly references them.
-- Do not pre-plan with todo_write for tasks that can be done in one or two tool calls.
-- Skip the "investigate the codebase" step that applies to larger changes.
+If a change you made caused an existing test to fail and you edited the test so the suite passes, restore the original behavior instead — weakening a test to make it pass is never acceptable. If the test changes are intentional (the request requires new expected behavior, or the test itself was wrong), keep them and state each modified test and the reason in your final summary. Then finish normally.
 `);
 }
-// Removed: buildFinalizeOpportunityReminder. Was paired with the verification
-// nag ladder. Without the ladder, "you can finalize now" advice is redundant —
-// the model finalises whenever its own judgement says the task is done.

package/dist/prompt/task-reminders.d.ts

@@ -1,18 +1,4 @@
-import type { TaskType } from "../agent/task-classifier.js";
 import { type RoutableModelEntry } from "../agent/routing-catalog.js";
-export interface TaskReminderOptions {
-    /** Whether this agent has the delegation tools (parent agents only). */
-    canDelegate?: boolean;
-}
-export declare function reminderForTaskType(taskType: TaskType, options?: TaskReminderOptions): string | undefined;
-/**
- * Deterministic detector for an explicit user request for a coordinated
- * multi-agent run. Three rounds of prompt wording lost to the model's
- * "agent team = parallel spawns" prior in live tests (opus-4.8, 2026-07-06);
- * per the task-reminder principle above, a reminder injected at the decision
- * turn is the lever that actually works — the harness remembers so the model
- * does not have to.
- */
 /**
  * User-named model resolution (model-routing design v3.6): when the user's
  * message names a model that exists in the routable catalog, hand the main
@@ -23,21 +9,4 @@ export declare function reminderForTaskType(taskType: TaskType, options?: TaskRe
  * this, 2026-07-12 live case). Silent on no match: zero standing noise.
  */
 export declare function userNamedModelReminder(input: string | import("../types.js").ContentPart[], routableModels: RoutableModelEntry[] | undefined, canSpawn: boolean): string | undefined;
-/**
- * Large-change checkpoint (large-task-delegation design §3): injected once
- * per session at the first mutation of a broad turn. Carries the routing
- * decision criteria (independent vs entangled) and the real worktree
- * mechanics (children fork from the last commit; disjoint file sets) —
- * never a command. The "smallest coherent edit" clause is lifted verbatim
- * from the implementation-workflow reminder so the two compose.
- */
-export interface LargeTaskReminderInput {
-    exploredFiles: number;
-    pendingTodos: number;
-    /** Mutations already applied this turn (the current batch lands regardless). */
-    appliedEdits: number;
-    /** orchestrationRequestReminder fired this turn: only offer run_workflow. */
-    orchestrationRequested: boolean;
-}
-export declare function largeImplementationTaskReminder(input: LargeTaskReminderInput): string;
 export declare function orchestrationRequestReminder(input: string | import("../types.js").ContentPart[], canRunWorkflow: boolean): string | undefined;

package/dist/prompt/task-reminders.js

@@ -1,76 +1,4 @@
 import { normalizeModelToken } from "../agent/routing-catalog.js";
-import { wrapInSystemReminder } from "./reminders.js";
-/**
- * Delegation nudge for exploration-shaped tasks: injected at the decision
- * point (start of turn), where it carries far more weight for weakly
- * delegating models than the session-start system prompt. Task-type gating
- * keeps it away from ordinary implementation/debugging turns, so it cannot
- * amplify over-delegation.
- */
-const DELEGATION_NUDGE = "- If answering needs scanning many files and only the conclusion matters, delegate to a background subagent (spawn_agent); when it is the same read-only question over several independent items, fan out with a run_workflow script.";
-export function reminderForTaskType(taskType, options = {}) {
-    switch (taskType) {
-        case "debugging":
-            return wrapInSystemReminder(`
-Debugging workflow:
-- Reproduce or identify the failing boundary before editing.
-- Trace input, transformation, and output paths.
-- Prefer fixing the mechanism over raising thresholds or adding superficial fallbacks.
-- Verify the specific failure path after the change.
-`);
-        case "implementation":
-            return wrapInSystemReminder(`
-Implementation workflow:
-- Do not stop at a proposal when the user asked for a change.
-- Inspect the relevant files first, then make the smallest coherent edit.
-- Keep unrelated files and behavior out of scope.
-- Verify the change, then run the existing tests of the affected module — not only the cases you added — or explain why they cannot be run.
-`);
-        case "code_review":
-            return wrapInSystemReminder(`
-Code review workflow:
-- Lead with concrete findings, ordered by severity.
-- Reference file paths and line numbers when possible.
-- Prioritize bugs, regressions, missing tests, security, and user-visible risk.
-- Keep summaries secondary to findings.
-`);
-        case "code_explanation":
-            return wrapInSystemReminder(`
-Code explanation workflow:
-- Answer the direct question first.
-- Ground claims in concrete files, functions, and call paths.
-- Distinguish current source evidence from inference.
-- Avoid proposing changes unless the user asks for them.
-`);
-        case "repo_orientation":
-            return wrapInSystemReminder(`
-Repository orientation workflow:
-- Start with the repo purpose and main execution paths.
-- Inspect README/package metadata plus core runtime files before summarizing.
-- Keep the first pass read-only unless the user asks for changes or runtime verification.
-${options.canDelegate ? `${DELEGATION_NUDGE}\n` : ""}`);
-        case "product_discussion":
-            return wrapInSystemReminder(`
-Product discussion workflow:
-- Clarify the product goal, user workflow, and tradeoffs before suggesting implementation.
-- Give direct product judgment when the user asks for direction.
-- Avoid drifting into code changes unless the user explicitly asks to execute.
-`);
-        case "security_investigation":
-        case "code_search":
-        case "general":
-        default:
-            return undefined;
-    }
-}
-/**
- * Deterministic detector for an explicit user request for a coordinated
- * multi-agent run. Three rounds of prompt wording lost to the model's
- * "agent team = parallel spawns" prior in live tests (opus-4.8, 2026-07-06);
- * per the task-reminder principle above, a reminder injected at the decision
- * turn is the lever that actually works — the harness remembers so the model
- * does not have to.
- */
 /**
  * User-named model resolution (model-routing design v3.6): when the user's
  * message names a model that exists in the routable catalog, hand the main
@@ -119,21 +47,6 @@ export function userNamedModelReminder(input, routableModels, canSpawn) {
         "Use these exact ids in spawn_agent / run_workflow `model` params; do not retype model ids from memory.",
     ].join("\n");
 }
-export function largeImplementationTaskReminder(input) {
-    const plan = input.pendingTodos > 0 ? ` (plan: ${input.pendingTodos} open todo items)` : "";
-    const applied = input.appliedEdits > 0
-        ? ` ${input.appliedEdits} edit${input.appliedEdits === 1 ? "" : "s"} from your current batch will land regardless.`
-        : "";
-    const mechanism = input.orchestrationRequested
-        ? "one run_workflow script (the user asked for a coordinated workflow — keep everything in it)"
-        : "write_worktree subagents (spawn_agent with the implementer profile) or one run_workflow script";
-    return wrapInSystemReminder(`
-Large-change checkpoint: you have read ${input.exploredFiles} files this turn${plan} and are starting to edit.${applied}
-- If the REMAINING edits form INDEPENDENT groups (per-module, per-file, same shape repeated), split them across ${mechanism}. Assign each child a DISJOINT file set; keep shared files (types, registries, exports) for yourself. Children fork from the last COMMIT — commit your applied edits first, or fold them into the child briefings. Each child still makes the smallest coherent edit for its group.
-- If the edits are ENTANGLED (shared state, one file feeding the next, order matters), delegation only adds merge risk — proceed yourself.
-- Work already small enough to finish directly: just finish it.
-`);
-}
 const ORCHESTRATION_REQUEST = /\b(?:workflows?|orchestrat\w*|agent[ -]?teams?|fan[ -]?out)\b|工作流|编排|(?:智能体|代理|agent)\s*(?:团队|小队)/i;
 export function orchestrationRequestReminder(input, canRunWorkflow) {
     if (!canRunWorkflow)

package/dist/provider-ai-sdk.d.ts

@@ -17,6 +17,8 @@ export interface AiSdkProviderOptions {
     apiKey: string;
     baseURL?: string;
     thinkingLevel?: ThinkingLevel;
+    /** User-configured extra headers, merged last (client-identity gates). */
+    headers?: Record<string, string>;
     /** Transport override for tests; defaults to the shared provider fetch. */
     fetch?: ProviderFetch;
 }

package/dist/provider-ai-sdk.js

@@ -21,6 +21,7 @@ const AI_SDK_PROVIDER_FACTORIES = {
         const provider = createGoogleGenerativeAI({
             apiKey: options.apiKey,
             ...(options.baseURL ? { baseURL: normalizeBaseURL(options.baseURL) } : {}),
+            ...(options.headers ? { headers: options.headers } : {}),
             fetch: (options.fetch ?? createProviderFetch({
                 providerName: "Google Gemini",
                 verboseEnvVar: "BUBBLE_AI_SDK_FETCH_VERBOSE",

package/dist/provider-anthropic.d.ts

@@ -7,6 +7,8 @@ export interface AnthropicProviderOptions {
     apiKey: string;
     baseURL: string;
     thinkingLevel?: ThinkingLevel;
+    /** User-configured extra headers, merged last (client-identity gates). */
+    headers?: Record<string, string>;
 }
 interface AnthropicRequest {
     model: string;

package/dist/provider-anthropic.js

@@ -627,7 +627,9 @@ function buildAnthropicHeaders(options, stream) {
     }
     if (stream)
         headers.accept = "text/event-stream";
-    return headers;
+    // User-configured headers win last: anthropic-protocol coding plans gate on
+    // client identity (e.g. a specific User-Agent), configured per provider.
+    return { ...headers, ...(options.headers ?? {}) };
 }
 async function readAnthropicErrorDetail(response) {
     try {

package/dist/provider-ark-responses.d.ts

@@ -4,6 +4,8 @@ export interface ArkResponsesProviderOptions {
     apiKey: string;
     baseURL: string;
     thinkingLevel?: ThinkingLevel;
+    /** User-configured extra headers, merged last (client-identity gates). */
+    headers?: Record<string, string>;
 }
 export declare function createArkResponsesProvider(options: ArkResponsesProviderOptions): Provider;
 export declare function buildArkResponsesBody(messages: ProviderMessage[], options: {

package/dist/provider-ark-responses.js

@@ -124,6 +124,7 @@ async function sendArkResponsesRequest(options, body, requestOptions) {
             "Authorization": `Bearer ${options.apiKey}`,
             "Content-Type": "application/json",
             "Accept": body.stream ? "text/event-stream" : "application/json",
+            ...(options.headers ?? {}),
         },
         body: JSON.stringify(body),
         signal: requestOptions.signal,

package/dist/provider-grok.d.ts

@@ -9,9 +9,21 @@
  */
 import type { OAuthCredentials } from "./oauth/types.js";
 import { type ChatGptFetch } from "./network/chatgpt-transport.js";
+import type { ThinkingLevel } from "./types.js";
 export declare const GROK_SUBSCRIPTION_BASE_URL = "https://cli-chat-proxy.grok.com/v1";
 export declare const GROK_CLIENT_VERSION = "0.2.93";
 export declare function isGrokSubscriptionBaseUrl(baseURL: string): boolean;
+/**
+ * Infer reasoning levels for a Grok model id the /models endpoint returned
+ * without metadata. Flagship reasoning models (grok-N.M) expose
+ * low/medium/high with thinking always on — matching the curated grok-4.5
+ * entry — while composer/fast/mini/flash variants have no effort control and
+ * map to the plain "off" ladder.
+ */
+export declare function inferGrokReasoningLevels(modelId: string): {
+    levels: ThinkingLevel[];
+    defaultLevel?: ThinkingLevel;
+};
 export declare function buildGrokSubscriptionHeaders(): Record<string, string>;
 export interface GrokAuthAdapter {
     getCredentials: () => OAuthCredentials | undefined | Promise<OAuthCredentials | undefined>;
@@ -24,3 +36,17 @@ export interface GrokAuthAdapter {
  * proactively refreshes) the stored OAuth credentials per request instead.
  */
 export declare function createGrokSubscriptionFetch(auth: GrokAuthAdapter, baseFetch?: ChatGptFetch): ChatGptFetch;
+/**
+ * Fetch the model list for a Grok subscription account. The CLI chat proxy
+ * gates on the grok-cli identity headers plus a fresh OAuth bearer, so this
+ * rides the same refreshing fetch used for chat requests instead of a raw
+ * global fetch. Throws on a non-2xx so callers fall back to the curated
+ * catalog when the proxy exposes no /models endpoint.
+ */
+export declare function fetchGrokSubscriptionModels(baseURL: string, auth: GrokAuthAdapter, options?: {
+    timeoutMs?: number;
+    fetch?: ChatGptFetch;
+}): Promise<Array<{
+    id: string;
+    name?: string;
+}>>;

package/dist/provider-grok.js

@@ -17,6 +17,20 @@ export function isGrokSubscriptionBaseUrl(baseURL) {
     const normalized = baseURL.trim().replace(/\/+$/, "");
     return normalized === GROK_SUBSCRIPTION_BASE_URL || normalized.startsWith(`${GROK_SUBSCRIPTION_BASE_URL}/`);
 }
+/**
+ * Infer reasoning levels for a Grok model id the /models endpoint returned
+ * without metadata. Flagship reasoning models (grok-N.M) expose
+ * low/medium/high with thinking always on — matching the curated grok-4.5
+ * entry — while composer/fast/mini/flash variants have no effort control and
+ * map to the plain "off" ladder.
+ */
+export function inferGrokReasoningLevels(modelId) {
+    const id = modelId.toLowerCase();
+    if (/(composer|fast|mini|flash)/.test(id)) {
+        return { levels: ["off"] };
+    }
+    return { levels: ["low", "medium", "high"], defaultLevel: "high" };
+}
 export function buildGrokSubscriptionHeaders() {
     return {
         "User-Agent": "grok-cli",
@@ -57,3 +71,28 @@ export function createGrokSubscriptionFetch(auth, baseFetch = getChatGptFetch())
         return baseFetch(input, { ...(init ?? {}), headers });
     };
 }
+/**
+ * Fetch the model list for a Grok subscription account. The CLI chat proxy
+ * gates on the grok-cli identity headers plus a fresh OAuth bearer, so this
+ * rides the same refreshing fetch used for chat requests instead of a raw
+ * global fetch. Throws on a non-2xx so callers fall back to the curated
+ * catalog when the proxy exposes no /models endpoint.
+ */
+export async function fetchGrokSubscriptionModels(baseURL, auth, options = {}) {
+    const fetchImpl = createGrokSubscriptionFetch(auth, options.fetch);
+    const base = baseURL.trim().replace(/\/+$/, "");
+    const response = await fetchImpl(`${base}/models`, {
+        headers: buildGrokSubscriptionHeaders(),
+        signal: AbortSignal.timeout(options.timeoutMs ?? 5_000),
+    });
+    if (!response.ok)
+        throw new Error(`HTTP ${response.status}`);
+    const payload = (await response.json());
+    const entries = payload.data ?? payload.models ?? [];
+    return entries
+        .filter((entry) => typeof entry?.id === "string" && entry.id.trim().length > 0)
+        .map((entry) => ({
+        id: entry.id,
+        name: typeof entry.name === "string" ? entry.name : undefined,
+    }));
+}

package/dist/provider-registry.d.ts

@@ -9,7 +9,7 @@ import { type ProviderProtocol } from "./model-catalog.js";
 import { ModelConfig } from "./model-config.js";
 import { AuthStorage } from "./oauth/index.js";
 import { type OpenAICodexAuthAdapter } from "./provider-openai-codex.js";
-import type { GrokAuthAdapter } from "./provider-grok.js";
+import { type GrokAuthAdapter } from "./provider-grok.js";
 import type { ThinkingLevel } from "./types.js";
 export interface ProviderProfile {
     id: string;
@@ -19,7 +19,20 @@ export interface ProviderProfile {
     enabled: boolean;
     authType?: "api" | "oauth";
     protocol?: ProviderProtocol;
+    /**
+     * Extra request headers sent with every call to this provider. The knob for
+     * client-identity gates: coding-plan endpoints commonly allowlist specific
+     * User-Agent strings (Grok wants "grok-cli", plans that "support Claude
+     * Code" check for its UA), so users can satisfy them from config without
+     * code changes. Merged over protocol defaults; same-name keys win.
+     */
+    headers?: Record<string, string>;
 }
+/** True for providers speaking the OpenAI chat-completions protocol (the default). */
+export declare function isOpenAICompatibleProtocol(protocol: ProviderProtocol | undefined): boolean;
+export declare function isLikelyChatModelId(id: string): boolean;
+/** Keep only string-valued headers; returns undefined for empty/invalid maps. */
+export declare function sanitizeProviderHeaders(value: unknown): Record<string, string> | undefined;
 export interface ModelInfo {
     id: string;
     name: string;