@bubblebrain-ai/bubble 0.0.46 → 0.0.47

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-registry.d.ts

@@ -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;

package/dist/provider-registry.js

@@ -12,8 +12,55 @@ import { fetchGeminiModels } from "./provider-ai-sdk.js";
 import { extractChatGptAccountId, fetchOpenAICodexModelCatalog } from "./provider-openai-codex.js";
 import { refreshOpenAICodex } from "./oauth/openai-codex.js";
 import { refreshGrok } from "./oauth/grok.js";
+/** True for providers speaking the OpenAI chat-completions protocol (the default). */
+export function isOpenAICompatibleProtocol(protocol) {
+    return protocol === undefined || protocol === "openai-chat";
+}
+/**
+ * Ids that are clearly not text chat models. Vendors with one big catalog
+ * (alibaba returns 236 entries) would otherwise flood the model picker.
+ * Deliberately conservative: vision/preview chat models must pass.
+ */
+const NON_CHAT_ID_PATTERN = /(^|[-_/])(embed|embedding|embeddings|rerank|reranker|tts|asr|whisper|ocr|moderation|guard|image|video|audio|speech|voice|paint|draw)([-_/]|$)/i;
+export function isLikelyChatModelId(id) {
+    return !NON_CHAT_ID_PATTERN.test(id);
+}
+/** GET {baseURL}/models, tolerating the common response shapes. */
+async function fetchOpenAICompatibleModelIds(provider) {
+    const base = provider.baseURL.replace(/\/+$/, "");
+    const response = await fetch(`${base}/models`, {
+        headers: {
+            Authorization: `Bearer ${provider.apiKey}`,
+            ...(provider.headers ?? {}),
+        },
+        signal: AbortSignal.timeout(MODEL_DISCOVERY_TIMEOUT_MS),
+    });
+    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,
+    }));
+}
+/** Keep only string-valued headers; returns undefined for empty/invalid maps. */
+export function sanitizeProviderHeaders(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const out = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (typeof raw === "string" && key.trim())
+            out[key] = raw;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
 const MODEL_DISCOVERY_SUCCESS_TTL_MS = 60_000;
 const MODEL_DISCOVERY_FAILURE_TTL_MS = 10_000;
+/** Discovery must never delay startup or a model picker for long. */
+const MODEL_DISCOVERY_TIMEOUT_MS = 5_000;
 export const BUILTIN_PROVIDERS = CATALOG_PROVIDERS;
 export const USER_VISIBLE_PROVIDER_IDS = BUILTIN_PROVIDERS
     .filter((provider) => !provider.hidden && provider.id !== "openrouter" && provider.id !== "openai-codex")
@@ -230,6 +277,7 @@ export class ProviderRegistry {
                     enabled: true,
                     authType: "api",
                     protocol: resolveConfiguredProtocol(id, baseURL, cfg.protocol),
+                    headers: sanitizeProviderHeaders(cfg.headers),
                 };
             });
         }
@@ -241,6 +289,7 @@ export class ProviderRegistry {
                     ...provider,
                     baseURL,
                     protocol: resolveConfiguredProtocol(provider.id, baseURL, provider.protocol),
+                    headers: sanitizeProviderHeaders(provider.headers),
                 };
             });
         }
@@ -472,6 +521,40 @@ export class ProviderRegistry {
                 return this.fallbackDiscovery(provider, error);
             }
         }
+        // Generic OpenAI-compatible discovery: most vendors expose GET /models on
+        // the same base URL. Probed against every configured provider, their lists
+        // turned out to be neither complete nor clean — zhipuai omits glm-5.2,
+        // stepfun omits step-3.7-flash (both demonstrably usable), alibaba returns
+        // 236 entries including image/audio models, fireworks 412s. So the remote
+        // list AUGMENTS the curated catalog instead of replacing it: builtin
+        // entries always survive (they carry tier/reasoning metadata and some work
+        // while unlisted), remote-only ids are appended, obvious non-chat
+        // modalities are filtered out. Not authoritative — membership is a union,
+        // so nothing downstream may treat it as a closed allowlist.
+        if (isOpenAICompatibleProtocol(provider.protocol) && provider.apiKey) {
+            try {
+                const remote = await fetchOpenAICompatibleModelIds(provider);
+                const local = this.localModelsForProvider(provider);
+                const known = new Set(local.map((model) => model.id));
+                const extras = remote
+                    .filter((entry) => !known.has(entry.id) && isLikelyChatModelId(entry.id))
+                    .map((entry) => ({
+                    id: entry.id,
+                    name: entry.name || entry.id,
+                    providerId: provider.id,
+                }))
+                    .sort((a, b) => a.id.localeCompare(b.id));
+                if (extras.length === 0) {
+                    return { models: local, source: "static", authoritative: true };
+                }
+                return { models: [...local, ...extras], source: "remote", authoritative: false };
+            }
+            catch {
+                // Vendors that don't implement /models (or gate it) fall back silently:
+                // the curated catalog is the contract, discovery is a bonus.
+                return { models: this.localModelsForProvider(provider), source: "static", authoritative: true };
+            }
+        }
         return {
             models: this.localModelsForProvider(provider),
             source: "static",

package/dist/provider-transform.js

@@ -2,7 +2,17 @@ import { getBuiltinModel } from "./model-catalog.js";
 import { getAvailableThinkingLevels, normalizeInheritedThinkingLevel, normalizeThinkingLevel } from "./variant/variant-resolver.js";
 export { getAvailableThinkingLevels, getDefaultThinkingLevel, isThinkingOnlyLevels, isThinkingOnlyModel, isThinkingToggleModel, normalizeInheritedThinkingLevel, normalizeThinkingLevel } from "./variant/variant-resolver.js";
 const MOONSHOT_PROVIDER_IDS = new Set(["moonshot-cn", "moonshot-intl", "kimi-for-coding"]);
-const KIMI_K27_FAMILY = new Set(["kimi-k2.7-code", "kimi-k2.7-code-highspeed"]);
+const KIMI_K27_FAMILY = new Set([
+    "kimi-k2.7-code",
+    "kimi-k2.7-code-highspeed",
+    // Coding-plan slot ids for the same generation (GET /coding/v1/models).
+    "kimi-for-coding",
+    "kimi-for-coding-highspeed",
+]);
+// K3 takes OpenAI-style reasoning_effort (low/high/max, no "medium"); "off"
+// disables thinking via top-level thinking.type. Verified live: effort changes
+// reasoning-token spend, and nested extra_body.thinking is ignored server-side.
+const KIMI_K3_FAMILY = new Set(["k3", "k3-256k", "kimi-k3"]);
 const KIMI_TOGGLE_THINKING_FAMILY = new Set(["kimi-k2.5", "kimi-k2.6"]);
 const KIMI_K26_DEFAULT_MAX_TOKENS = 32768;
 const MINIMAX_M3_FAMILY = new Set(["MiniMax-M3"]);
@@ -60,6 +70,18 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
             },
         };
     }
+    // Bailian token plan speaks OpenAI-compatible reasoning_effort, with "none"
+    // as its off value (verified: enable_thinking=false works too, but "none"
+    // keeps one parameter for every level). Grades are validated server-side —
+    // an unknown value is a 400 — so the catalog's per-model ladder matters.
+    if (providerId === "bailian-token-plan") {
+        return {
+            effectiveThinkingLevel,
+            extraBody: {
+                reasoning_effort: effectiveThinkingLevel === "off" ? "none" : effectiveThinkingLevel,
+            },
+        };
+    }
     if (providerId === "stepfun") {
         return {
             effectiveThinkingLevel,
@@ -137,6 +159,20 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
                 },
             };
         }
+        if (KIMI_K3_FAMILY.has(modelId)) {
+            return {
+                effectiveThinkingLevel,
+                omitTemperature: true,
+                reasoningContentEcho: "tool_calls",
+                // extraBody spreads onto the request body verbatim. The sibling
+                // `reasoningEffort` field is NOT the same thing: the generic chat path
+                // turns it into OpenRouter's `reasoning: {enabled: true}`, which drops
+                // the grade entirely.
+                extraBody: effectiveThinkingLevel === "off"
+                    ? { thinking: { type: "disabled" } }
+                    : { reasoning_effort: effectiveThinkingLevel },
+            };
+        }
         if (KIMI_TOGGLE_THINKING_FAMILY.has(modelId)) {
             return {
                 effectiveThinkingLevel,

package/dist/provider.d.ts

@@ -28,6 +28,13 @@ export interface ProviderInstanceOptions {
     /** Stable per-session seed for provider prompt caches. */
     promptCacheKey?: string;
     protocol?: ProviderProtocol;
+    /**
+     * User-configured extra request headers (provider entry `headers` in
+     * config.json/models.json). Merged over protocol defaults, so a coding-plan
+     * endpoint's client-identity gate (usually a User-Agent allowlist) can be
+     * satisfied from config.
+     */
+    headers?: Record<string, string>;
     /** Dynamic OAuth access-token loader/refresh hook for ChatGPT Codex requests. */
     openAICodexAuth?: OpenAICodexAuthAdapter;
     /** Dynamic OAuth access-token loader/refresh hook for Grok subscription requests. */