@hiai-gg/hiai-opencode 0.1.3 → 0.1.5

package/src/config/platform-schema.ts

@@ -8,6 +8,37 @@ export const AgentConfigSchema = z.object({
   description: z.string().optional(),
 });
 
+export const ModelRecommendationSchema = z.enum([
+  "xhigh",
+  "high",
+  "middle",
+  "fast",
+  "vision",
+  "writing",
+  "design",
+]);
+
+export const ModelSlotConfigSchema = z.union([
+  z.string(),
+  z.object({
+    model: z.string(),
+    recommended: ModelRecommendationSchema.optional(),
+  }),
+]);
+
+export const ModelSlotsConfigSchema = z.object({
+  bob: ModelSlotConfigSchema.optional(),
+  coder: ModelSlotConfigSchema.optional(),
+  strategist: ModelSlotConfigSchema.optional(),
+  guard: ModelSlotConfigSchema.optional(),
+  critic: ModelSlotConfigSchema.optional(),
+  designer: ModelSlotConfigSchema.optional(),
+  researcher: ModelSlotConfigSchema.optional(),
+  manager: ModelSlotConfigSchema.optional(),
+  brainstormer: ModelSlotConfigSchema.optional(),
+  vision: ModelSlotConfigSchema.optional(),
+});
+
 export const FallbackEntrySchema = z.object({
   providers: z.array(z.string()),
   model: z.string(),
@@ -48,8 +79,9 @@ export const McpServerConfigSchema = z.object({
 });
 
 export const LspServerConfigSchema = z.object({
-  command: z.array(z.string()),
-  extensions: z.array(z.string()),
+  enabled: z.boolean().optional(),
+  command: z.array(z.string()).optional(),
+  extensions: z.array(z.string()).optional(),
   initialization: z.record(z.string(), z.unknown()).optional(),
 });
 
@@ -63,6 +95,16 @@ export const SkillsConfigSchema = z.object({
   disabled: z.array(z.string()).optional(),
 });
 
+export const SkillDiscoveryConfigSchema = z.object({
+  config_sources: z.boolean().optional(),
+  project_opencode: z.boolean().optional(),
+  global_opencode: z.boolean().optional(),
+  project_claude: z.boolean().optional(),
+  global_claude: z.boolean().optional(),
+  project_agents: z.boolean().optional(),
+  global_agents: z.boolean().optional(),
+});
+
 export const PermissionsConfigSchema = z.object({
   read: z.record(z.string(), z.string()).optional(),
   edit: z.record(z.string(), z.string()).optional(),
@@ -92,12 +134,13 @@ export const AuthKeysSchema = z.object({
   openrouter: z.string().optional(),
   stitch: z.string().optional(),
   firecrawl: z.string().optional(),
+  context7: z.string().optional(),
 });
 
 export const OllamaConfigSchema = z.object({
   enabled: z.boolean().default(false),
-  model: z.string().default("qwen3.5:4b"),
-  baseUrl: z.string().default("http://localhost:11434"),
+  model: z.string().default(""),
+  baseUrl: z.string().default(""),
   purpose: z.enum(["verification", "helper", "fallback"]).default("helper"),
 });
 
@@ -130,6 +173,8 @@ const AgentsConfigSchema = z.object({
   zoe: AgentConfigSchema.optional(),
   build: AgentConfigSchema.optional(),
   "pre-plan": AgentConfigSchema.optional(),
+  manager: AgentConfigSchema.optional(),
+  vision: AgentConfigSchema.optional(),
   logician: AgentConfigSchema.optional(),
   librarian: AgentConfigSchema.optional(),
   explore: AgentConfigSchema.optional(),
@@ -162,6 +207,8 @@ const AgentRequirementsConfigSchema = z.object({
   zoe: ModelRequirementSchema.optional(),
   build: ModelRequirementSchema.optional(),
   "pre-plan": ModelRequirementSchema.optional(),
+  manager: ModelRequirementSchema.optional(),
+  vision: ModelRequirementSchema.optional(),
   logician: ModelRequirementSchema.optional(),
   librarian: ModelRequirementSchema.optional(),
   explore: ModelRequirementSchema.optional(),
@@ -176,6 +223,7 @@ const AgentRequirementsConfigSchema = z.object({
 
 export const HiaiOpencodeConfigSchema = z.object({
   $schema: z.string().optional(),
+  models: ModelSlotsConfigSchema.optional(),
   agents: AgentsConfigSchema.optional(),
   agentRequirements: AgentRequirementsConfigSchema.optional(),
   categories: z.record(z.string(), CategoryConfigSchema).optional(),
@@ -185,6 +233,7 @@ export const HiaiOpencodeConfigSchema = z.object({
   lsp: z.record(z.string(), LspServerConfigSchema).optional(),
   subtask2: Subtask2ConfigSchema.optional(),
   skills: SkillsConfigSchema.optional(),
+  skill_discovery: SkillDiscoveryConfigSchema.optional(),
   permissions: PermissionsConfigSchema.optional(),
   auth: AuthKeysSchema.optional(),
   ollama: OllamaConfigSchema.optional(),

package/src/config/schema/agent-overrides.ts

@@ -79,6 +79,8 @@ export const AgentOverridesSchema = z.object({
   general: AgentOverrideConfigSchema.optional(),
   zoe: AgentOverrideConfigSchema.optional(),
   "pre-plan": AgentOverrideConfigSchema.optional(),
+  manager: AgentOverrideConfigSchema.optional(),
+  vision: AgentOverrideConfigSchema.optional(),
   "logician": AgentOverrideConfigSchema.optional(),
   librarian: AgentOverrideConfigSchema.optional(),
   explore: AgentOverrideConfigSchema.optional(),

package/src/config/schema/commands.ts

@@ -9,6 +9,7 @@ export const BuiltinCommandNameSchema = z.enum([
   "start-work",
   "stop-continuation",
   "remove-ai-slops",
+  "mcp-status",
 ])
 
 export type BuiltinCommandName = z.infer<typeof BuiltinCommandNameSchema>

package/src/config/schema/fast-apply.ts

@@ -3,10 +3,10 @@ import { z } from "zod"
 export const FastApplyConfigSchema = z.object({
   /** Enable fast-apply via Ollama (default: false) */
   enabled: z.boolean().optional().default(false),
-  /** Ollama API URL (default: http://localhost:11434) */
-  ollama_url: z.string().optional().default("http://localhost:11434"),
-  /** Model name for fast-apply (default: qwen3.5:9b) */
-  model: z.string().optional().default("qwen3.5:9b"),
+  /** Ollama API URL. Configure in hiai-opencode.json. */
+  ollama_url: z.string().optional().default(""),
+  /** Model name for fast-apply. Configure in hiai-opencode.json. */
+  model: z.string().optional().default(""),
   /** Timeout in milliseconds for Ollama request (default: 30000) */
   timeout: z.number().int().positive().optional().default(30000),
 })

package/src/config/schema/index.ts

@@ -44,6 +44,8 @@ export { BobAgentConfigSchema } from "./bob-agent"
 export type { BobAgentConfig } from "./bob-agent"
 export { SkillsConfigSchema } from "./skills"
 export type { SkillsConfig, SkillDefinition } from "./skills"
+export { SkillDiscoveryConfigSchema } from "./skill-discovery"
+export type { SkillDiscoveryConfig } from "./skill-discovery"
 export { StartWorkConfigSchema } from "./start-work"
 export type { StartWorkConfig } from "./start-work"
 export { TmuxConfigSchema, TmuxLayoutSchema, TmuxIsolationSchema } from "./tmux"

package/src/config/schema/oh-my-opencode-config.ts

@@ -17,6 +17,7 @@ import { ModelCapabilitiesConfigSchema } from "./model-capabilities"
 import { RalphLoopConfigSchema } from "./ralph-loop"
 import { RuntimeFallbackConfigSchema } from "./runtime-fallback"
 import { SkillsConfigSchema } from "./skills"
+import { SkillDiscoveryConfigSchema } from "./skill-discovery"
 import { BobConfigSchema } from "./bob"
 import { BobAgentConfigSchema } from "./bob-agent"
 import { TmuxConfigSchema } from "./tmux"
@@ -30,6 +31,7 @@ const AuthConfigSchema = z.object({
   openrouter: z.string().optional(),
   stitch: z.string().optional(),
   firecrawl: z.string().optional(),
+  context7: z.string().optional(),
 }).optional()
 
 export const HiaiOpenCodeConfigSchema = z.object({
@@ -60,6 +62,7 @@ export const HiaiOpenCodeConfigSchema = z.object({
   experimental: ExperimentalConfigSchema.optional(),
   auto_update: z.boolean().optional(),
   skills: SkillsConfigSchema.optional(),
+  skill_discovery: SkillDiscoveryConfigSchema.optional(),
   ralph_loop: RalphLoopConfigSchema.optional(),
   /**
    * Enable runtime fallback (default: false)

package/src/config/schema/skill-discovery.ts

@@ -0,0 +1,25 @@
+import { z } from "zod"
+
+export const SkillDiscoveryConfigSchema = z.object({
+  /**
+   * Explicit skills.sources entries from hiai-opencode config.
+   * Safe by default because the user intentionally configured them.
+   */
+  config_sources: z.boolean().default(true),
+  /**
+   * Project-local OpenCode skills: .opencode/skills and .opencode/skill.
+   * Kept on by default because they are part of the current project contract.
+   */
+  project_opencode: z.boolean().default(true),
+  /**
+   * Global OpenCode skills from the user's OpenCode config directory.
+   * Off by default to keep clean installs deterministic.
+   */
+  global_opencode: z.boolean().default(false),
+  project_claude: z.boolean().default(false),
+  global_claude: z.boolean().default(false),
+  project_agents: z.boolean().default(false),
+  global_agents: z.boolean().default(false),
+})
+
+export type SkillDiscoveryConfig = z.infer<typeof SkillDiscoveryConfigSchema>

package/src/config/types.ts

@@ -7,6 +7,35 @@ export interface AgentConfig {
   description?: string;
 }
 
+export type ModelRecommendation =
+  | "xhigh"
+  | "high"
+  | "middle"
+  | "fast"
+  | "vision"
+  | "writing"
+  | "design";
+
+export type ModelSlotConfig =
+  | string
+  | {
+      model: string;
+      recommended?: ModelRecommendation;
+    };
+
+export interface ModelSlotsConfig {
+  bob?: ModelSlotConfig;
+  coder?: ModelSlotConfig;
+  strategist?: ModelSlotConfig;
+  guard?: ModelSlotConfig;
+  critic?: ModelSlotConfig;
+  designer?: ModelSlotConfig;
+  researcher?: ModelSlotConfig;
+  manager?: ModelSlotConfig;
+  brainstormer?: ModelSlotConfig;
+  vision?: ModelSlotConfig;
+}
+
 // Canonical 12-agent model exposed by schema/default config.
 export const CANONICAL_AGENT_NAMES = [
   "bob",
@@ -32,6 +61,8 @@ export const LEGACY_AGENT_ALIAS_NAMES = [
   "zoe",
   "build",
   "pre-plan",
+  "manager",
+  "vision",
   "logician",
   "librarian",
   "explore",
@@ -54,6 +85,8 @@ export const LEGACY_AGENT_ALIAS_TO_CANONICAL: Record<
   zoe: "bob",
   build: "bob",
   "pre-plan": "strategist",
+  manager: "platform-manager",
+  vision: "multimodal",
   logician: "strategist",
   librarian: "researcher",
   explore: "researcher",
@@ -120,8 +153,9 @@ export interface McpServerConfig {
 }
 
 export interface LspServerConfig {
-  command: string[];
-  extensions: string[];
+  enabled?: boolean;
+  command?: string[];
+  extensions?: string[];
   initialization?: Record<string, unknown>;
 }
 
@@ -135,6 +169,16 @@ export interface SkillsConfig {
   disabled?: string[];
 }
 
+export interface SkillDiscoveryConfig {
+  config_sources?: boolean;
+  project_opencode?: boolean;
+  global_opencode?: boolean;
+  project_claude?: boolean;
+  global_claude?: boolean;
+  project_agents?: boolean;
+  global_agents?: boolean;
+}
+
 export interface PermissionsConfig {
   read?: Record<string, string>;
   edit?: Record<string, string>;
@@ -148,6 +192,7 @@ export interface AuthKeys {
   openrouter?: string;
   stitch?: string;
   firecrawl?: string;
+  context7?: string;
 }
 
 export interface OllamaConfig {
@@ -159,6 +204,7 @@ export interface OllamaConfig {
 
 export interface HiaiOpencodeConfig {
   $schema?: string;
+  models?: ModelSlotsConfig;
   agents?: AgentConfigMap;
   agentRequirements?: AgentRequirementMap;
   categories?: Record<string, CategoryConfig>;
@@ -168,6 +214,7 @@ export interface HiaiOpencodeConfig {
   lsp?: Record<string, LspServerConfig>;
   subtask2?: Subtask2Config;
   skills?: SkillsConfig;
+  skill_discovery?: SkillDiscoveryConfig;
   permissions?: PermissionsConfig;
   auth?: AuthKeys;
   ollama?: OllamaConfig;

package/src/create-tools.ts

@@ -1,5 +1,6 @@
 import type { AvailableCategory, AvailableSkill } from "./agents/dynamic-agent-prompt-builder"
 import type { HiaiOpenCodeConfig } from "./config"
+import type { HiaiOpencodeConfig } from "./config/types"
 import type { BrowserAutomationProvider } from "./config/schema/browser-automation"
 import type { LoadedSkill } from "./features/opencode-skill-loader/types"
 import type { PluginContext, ToolsRecord } from "./plugin/types"
@@ -22,9 +23,10 @@ type CreateToolsResult = {
 export async function createTools(args: {
   ctx: PluginContext
   pluginConfig: HiaiOpenCodeConfig
+  platformConfig?: HiaiOpencodeConfig
   managers: Pick<Managers, "backgroundManager" | "tmuxSessionManager" | "skillMcpManager">
 }): Promise<CreateToolsResult> {
-  const { ctx, pluginConfig, managers } = args
+  const { ctx, pluginConfig, platformConfig, managers } = args
 
   const skillContext = await createSkillContext({
     directory: ctx.directory,
@@ -39,6 +41,7 @@ export async function createTools(args: {
     managers,
     skillContext,
     availableCategories,
+    builtinMcp: platformConfig?.mcp,
   })
 
   return {

package/src/features/builtin-commands/commands.ts

@@ -8,6 +8,7 @@ import { REFACTOR_TEMPLATE } from "./templates/refactor"
 import { START_WORK_TEMPLATE } from "./templates/start-work"
 import { HANDOFF_TEMPLATE } from "./templates/handoff"
 import { REMOVE_AI_SLOPS_TEMPLATE } from "./templates/remove-ai-slops"
+import { MCP_STATUS_TEMPLATE } from "./templates/mcp-status"
 
 interface LoadBuiltinCommandsOptions {
   useRegisteredAgents?: boolean
@@ -121,6 +122,12 @@ $ARGUMENTS
 </user-request>`,
       argumentHint: "[goal]",
     },
+    "mcp-status": {
+      description: "(builtin) Show hiai-opencode MCP server status, missing keys, and local runtime availability",
+      template: `<command-instruction>
+${MCP_STATUS_TEMPLATE}
+</command-instruction>`,
+    },
   }
 }
 

package/src/features/builtin-commands/templates/mcp-status.ts

@@ -0,0 +1,36 @@
+export const MCP_STATUS_TEMPLATE = `# MCP Status Command
+
+## Purpose
+
+Use /mcp-status to show the effective hiai-opencode MCP setup without relying on OpenCode's mcp list output.
+
+## Execute
+
+Run:
+
+\`\`\`bash
+hiai-opencode mcp-status
+\`\`\`
+
+If the binary is not on PATH, try the package-local fallback:
+
+\`\`\`bash
+node ./node_modules/@hiai-gg/hiai-opencode/assets/cli/hiai-opencode.mjs mcp-status
+\`\`\`
+
+## Report
+
+Summarize the output in a compact status table:
+
+- MCP server name
+- status: ok, warning, error, disabled
+- cause or next action
+
+Rules:
+
+- Do not print API key values.
+- If a key is missing, name the env var only.
+- If a runtime is missing, give the exact install hint from the command output or the shortest safe next command.
+- Do not edit config unless the user explicitly asks.
+- Do not run package installs unless the user explicitly asks.
+`

package/src/features/builtin-commands/types.ts

@@ -1,6 +1,6 @@
 import type { CommandDefinition } from "../claude-code-command-loader"
 
-export type BuiltinCommandName = "init-deep" | "ralph-loop" | "cancel-ralph" | "ulw-loop" | "refactor" | "start-work" | "stop-continuation" | "handoff" | "remove-ai-slops"
+export type BuiltinCommandName = "init-deep" | "ralph-loop" | "cancel-ralph" | "ulw-loop" | "refactor" | "start-work" | "stop-continuation" | "handoff" | "remove-ai-slops" | "mcp-status"
 
 export interface BuiltinCommandConfig {
   disabled_commands?: BuiltinCommandName[]

package/src/features/builtin-skills/skills/playwright.ts

@@ -5,11 +5,33 @@ export const playwrightSkill: BuiltinSkill = {
   description: "MUST USE for any browser-related tasks. Browser automation via Playwright MCP - verification, browsing, information gathering, web scraping, testing, screenshots, and all browser interactions.",
   template: `# Playwright Browser Automation
 
-This skill provides browser automation capabilities via the Playwright MCP server.`,
+This skill provides browser automation capabilities via the Playwright MCP server.
+
+## Required workflow
+
+1. Load this skill before calling \`skill_mcp\`.
+2. Use \`skill_mcp\` with \`mcp_name="playwright"\` for browser navigation, interaction, screenshots, and visual verification.
+3. If the host says \`MCP server "playwright" not found\`, do not conclude that Playwright is impossible. First report that the skill was not loaded or the Playwright MCP server was not registered in this session.
+4. If Chromium starts but fails with missing Linux libraries such as \`libnspr4\`, \`libnss3\`, \`libatk-bridge\`, \`libgtk-3\`, or similar, distinguish browser OS dependencies from MCP availability.
+
+## Linux dependency fallback
+
+Playwright has two dependency layers:
+
+- Browser binary: installable without sudo with \`npx playwright install chromium\` or by setting \`HIAI_PLAYWRIGHT_INSTALL_BROWSERS=1\` before OpenCode starts.
+- System libraries: on minimal Linux images these usually require admin rights via \`sudo npx playwright install-deps chromium\` or OS package manager equivalents.
+
+If sudo is unavailable, try these alternatives before falling back to curl-only checks:
+
+- Use an already installed Chrome/Chromium/Edge by adding Playwright MCP args in \`hiai-opencode.json\`, for example \`--browser chrome\` or \`--browser msedge\`.
+- Use a remote/browser service or CDP-backed browser when available.
+- Switch the browser automation provider to \`agent-browser\` or \`playwright-cli\` if the workspace has those tools installed.
+
+Only use \`curl\` as a final degraded check. Clearly say that HTTP checks do not replace interactive browser verification.`,
   mcpConfig: {
     playwright: {
       command: "npx",
-      args: ["@playwright/mcp@latest"],
+      args: ["-y", "@playwright/mcp@latest"],
     },
   },
 }

package/src/features/opencode-skill-loader/loader.ts

@@ -62,6 +62,12 @@ export async function loadGlobalAgentsSkills(): Promise<Record<string, CommandDe
   return skillsToCommandDefinitionRecord(skills)
 }
 
+export async function loadManagedPluginSkills(): Promise<Record<string, CommandDefinition>> {
+  const skillsDir = join(getOpenCodeConfigDir({ binary: "opencode" }), ".hiai", "skills", "plugin")
+  const skills = await loadSkillsFromDir({ skillsDir, scope: "builtin" })
+  return skillsToCommandDefinitionRecord(skills)
+}
+
 export interface DiscoverSkillsOptions {
   includeClaudeCodePaths?: boolean
   directory?: string
@@ -170,3 +176,8 @@ export async function discoverGlobalAgentsSkills(): Promise<LoadedSkill[]> {
   const agentsGlobalDir = join(getAgentsConfigDir(), "skills")
   return loadSkillsFromDir({ skillsDir: agentsGlobalDir, scope: "user" })
 }
+
+export async function discoverManagedPluginSkills(): Promise<LoadedSkill[]> {
+  const skillsDir = join(getOpenCodeConfigDir({ binary: "opencode" }), ".hiai", "skills", "plugin")
+  return loadSkillsFromDir({ skillsDir, scope: "builtin" })
+}

package/src/index.ts

@@ -18,6 +18,7 @@ import { injectServerAuthIntoClient, log } from "./shared"
 import { hydratePluginConfigWithPlatformDefaults } from "./shared/runtime-plugin-config"
 import { detectExternalSkillPlugin, getSkillPluginConflictWarning } from "./shared/external-plugin-detector"
 import { PLUGIN_NAME } from "./shared/plugin-identity"
+import { warnIfListPluginEntry, warnMissingRequiredMcpEnv } from "./shared/startup-diagnostics"
 import { startBackgroundCheck as startTmuxCheck } from "./tools/interactive-bash"
 import { lspManager } from "./tools/lsp/client"
 
@@ -26,9 +27,13 @@ import type { HiaiOpencodeConfig } from "./config/types"
 
 import { createPlugin as createSubtask2Plugin } from "./internals/plugins/subtask2/core/plugin"
 import WebsearchCitedPlugin, { 
+  GOOGLE_PROVIDER_ID,
+  OPENAI_PROVIDER_ID,
+  OPENROUTER_PROVIDER_ID,
   WebsearchCitedGooglePlugin, 
   WebsearchCitedOpenAIPlugin 
 } from "./internals/plugins/websearch-cited/index"
+import type { WebsearchCitedFallback } from "./internals/plugins/websearch-cited/index"
 import { createBuiltinSkills } from "./features/builtin-skills"
 import {
   materializeBuiltinSkills,
@@ -37,6 +42,39 @@ import {
 
 let activePluginDispose: PluginDispose | null = null
 
+function createWebsearchFallback(config: HiaiOpencodeConfig): WebsearchCitedFallback | undefined {
+  const model = config.agents?.researcher?.model?.trim()
+  if (!model) {
+    return undefined
+  }
+
+  if (model.startsWith("openrouter/")) {
+    return {
+      providerID: OPENROUTER_PROVIDER_ID,
+      model: model.slice("openrouter/".length),
+    }
+  }
+
+  if (model.startsWith("openai/")) {
+    return {
+      providerID: OPENAI_PROVIDER_ID,
+      model: model.slice("openai/".length),
+    }
+  }
+
+  if (model.startsWith("google/")) {
+    return {
+      providerID: GOOGLE_PROVIDER_ID,
+      model: model.slice("google/".length),
+    }
+  }
+
+  return {
+    providerID: OPENROUTER_PROVIDER_ID,
+    model,
+  }
+}
+
 function configureBundledBunPtyLibrary(): void {
   if (process.env.BUN_PTY_LIB?.trim()) {
     return
@@ -69,6 +107,7 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
   log("[HiaiOpenCodePlugin] ENTRY - plugin loading", {
     directory: ctx.directory,
   })
+  warnIfListPluginEntry(ctx.directory)
 
   const skillPluginCheck = detectExternalSkillPlugin(ctx.directory)
   if (skillPluginCheck.detected && skillPluginCheck.pluginName) {
@@ -83,6 +122,10 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
     loadPluginConfig(ctx.directory, ctx),
     internalConfig,
   )
+  warnMissingRequiredMcpEnv({
+    pluginConfig,
+    platformConfig: internalConfig,
+  })
 
   materializeBuiltinSkills(
     createBuiltinSkills({
@@ -123,6 +166,7 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
   const toolsResult = await createTools({
     ctx,
     pluginConfig,
+    platformConfig: internalConfig,
     managers,
   })
 
@@ -163,7 +207,7 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
   } catch (err) {
     console.error("[hiai-opencode] PTYPlugin failed to load:", err);
   }
-  const websearchResult = await WebsearchCitedPlugin(ctx)
+  const websearchResult = await WebsearchCitedPlugin(ctx, createWebsearchFallback(internalConfig))
   const websearchGoogleResult = await WebsearchCitedGooglePlugin(ctx)
   const websearchOpenAIResult = await WebsearchCitedOpenAIPlugin(ctx)
 
@@ -220,29 +264,24 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
     auth: {
       provider: "hiai-opencode",
       methods: [
-        { type: "api" as const, label: "Google API key" },
-        { type: "api" as const, label: "OpenAI API key" },
-        { type: "api" as const, label: "OpenRouter API key" },
+        { type: "api" as const, label: "Google Search API key" },
       ],
       loader: async (getAuth: any) => {
         const authData = await getAuth();
         const { registerGetAuth, GOOGLE_PROVIDER_ID, OPENAI_PROVIDER_ID, OPENROUTER_PROVIDER_ID } = await import("./internals/plugins/websearch-cited/index");
 
-        // Helper to get key from config or authData
-        const getKey = (label: string, configKey?: string) => {
-          const fromAuth = authData[label];
-          if (fromAuth) return fromAuth;
+        const getConfiguredKey = (configKey?: string) => {
           if (configKey) return resolveEnvVars(configKey);
           return undefined;
         };
 
-        const googleKey = getKey("Google API key", internalConfig.auth?.googleSearch);
-        const openaiKey = getKey("OpenAI API key", internalConfig.auth?.openai);
-        const openRouterKey = getKey("OpenRouter API key", internalConfig.auth?.openrouter);
+        const googleKey = authData["Google Search API key"] || getConfiguredKey(internalConfig.auth?.googleSearch);
+        const openaiKey = getConfiguredKey(internalConfig.auth?.openai);
+        const openRouterKey = getConfiguredKey(internalConfig.auth?.openrouter);
 
-        if (googleKey) registerGetAuth(GOOGLE_PROVIDER_ID, () => Promise.resolve(googleKey));
-        if (openaiKey) registerGetAuth(OPENAI_PROVIDER_ID, () => Promise.resolve(openaiKey));
-        if (openRouterKey) registerGetAuth(OPENROUTER_PROVIDER_ID, () => Promise.resolve(openRouterKey));
+        if (googleKey) registerGetAuth(GOOGLE_PROVIDER_ID, () => Promise.resolve({ type: "api", key: googleKey }));
+        if (openaiKey) registerGetAuth(OPENAI_PROVIDER_ID, () => Promise.resolve({ type: "api", key: openaiKey }));
+        if (openRouterKey) registerGetAuth(OPENROUTER_PROVIDER_ID, () => Promise.resolve({ type: "api", key: openRouterKey }));
 
         return {};
       },

package/src/internals/plugins/websearch-cited/index.ts

@@ -44,6 +44,8 @@ type SelectedWebsearchConfig = {
 	model: string;
 };
 
+export type WebsearchCitedFallback = SelectedWebsearchConfig;
+
 type WebsearchCitedSelection = {
 	selected?: SelectedWebsearchConfig;
 	error?: string;
@@ -164,16 +166,16 @@ function parseOpenAIOptions(providerConfig: unknown, model: string | undefined):
 	return result;
 }
 
-const WebsearchCitedPlugin: Plugin = () => {
-	let selectedProvider: SelectedProviderID | undefined;
-	let selectedModel: string | undefined;
+const WebsearchCitedPlugin = (_ctx?: unknown, fallback?: WebsearchCitedFallback): Promise<any> => {
+	let selectedProvider: SelectedProviderID | undefined = fallback?.providerID;
+	let selectedModel: string | undefined = fallback?.model;
 	let openaiConfig: OpenAIWebsearchConfig = {};
 	let configError: string | undefined;
 
 	return Promise.resolve({
 		auth: {
 			provider: OPENROUTER_PROVIDER_ID,
-			loader(getAuth) {
+			loader(getAuth: GetAuth) {
 				registerGetAuth(OPENROUTER_PROVIDER_ID, getAuth);
 				return Promise.resolve({});
 			},
@@ -184,7 +186,7 @@ const WebsearchCitedPlugin: Plugin = () => {
 				},
 			],
 		},
-		config: (config) => {
+		config: (config: Config) => {
 			const { selected, error } = findFirstWebsearchCitedConfig(config as any);
 
 			selectedProvider = undefined;
@@ -199,6 +201,9 @@ const WebsearchCitedPlugin: Plugin = () => {
 					const openaiProvider = config.provider?.openai;
 					openaiConfig = parseOpenAIOptions(openaiProvider, selectedModel);
 				}
+			} else if (!error && fallback) {
+				selectedProvider = fallback.providerID;
+				selectedModel = fallback.model;
 			}
 
 			return Promise.resolve();

package/src/lsp/index.ts

@@ -4,6 +4,7 @@ export function buildLspConfig(lsp: Record<string, LspServerConfig>): Record<str
   const result: Record<string, unknown> = {};
 
   for (const [name, server] of Object.entries(lsp)) {
+    if (server.enabled === false) continue;
     result[name] = {
       command: server.command,
       extensions: server.extensions,