@hiai-gg/hiai-opencode 0.1.4 → 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(),
 });
 
@@ -102,6 +134,7 @@ 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({
@@ -190,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(),

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",
@@ -124,8 +153,9 @@ export interface McpServerConfig {
 }
 
 export interface LspServerConfig {
-  command: string[];
-  extensions: string[];
+  enabled?: boolean;
+  command?: string[];
+  extensions?: string[];
   initialization?: Record<string, unknown>;
 }
 
@@ -174,6 +204,7 @@ export interface OllamaConfig {
 
 export interface HiaiOpencodeConfig {
   $schema?: string;
+  models?: ModelSlotsConfig;
   agents?: AgentConfigMap;
   agentRequirements?: AgentRequirementMap;
   categories?: Record<string, CategoryConfig>;

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/index.ts

@@ -27,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,
@@ -38,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
@@ -129,6 +166,7 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
   const toolsResult = await createTools({
     ctx,
     pluginConfig,
+    platformConfig: internalConfig,
     managers,
   })
 
@@ -169,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)
 

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,

package/src/mcp/registry.ts

@@ -1,4 +1,5 @@
 import { join } from "node:path"
+import { existsSync } from "node:fs"
 import type { McpServerConfig } from "../config/types.js"
 
 export type HiaiMcpName =
@@ -22,7 +23,11 @@ export interface HiaiMcpRegistryEntry {
 }
 
 function resolveAssetScript(...segments: string[]): string {
-  return join(import.meta.dirname, "..", "assets", ...segments)
+  const candidates = [
+    join(import.meta.dirname, "..", "assets", ...segments),
+    join(import.meta.dirname, "..", "..", "assets", ...segments),
+  ]
+  return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0]
 }
 
 function createNpmPackageCommand(pkg: string, ...args: string[]): string[] {

package/src/plugin/tool-registry.ts

@@ -5,6 +5,7 @@ import type {
   AvailableCategory,
 } from "../agents/dynamic-agent-prompt-builder"
 import type { HiaiOpenCodeConfig } from "../config"
+import type { McpServerConfig } from "../config/types"
 import { isInteractiveBashEnabled } from "../create-runtime-tmux-config"
 import type { PluginContext, ToolsRecord } from "./types"
 
@@ -146,6 +147,7 @@ export function createToolRegistry(args: {
   managers: Pick<Managers, "backgroundManager" | "tmuxSessionManager" | "skillMcpManager">
   skillContext: SkillContext
   availableCategories: AvailableCategory[]
+  builtinMcp?: Record<string, McpServerConfig>
   interactiveBashEnabled?: boolean
   toolFactories?: Partial<ToolRegistryFactories>
 }): ToolRegistryResult {
@@ -155,6 +157,7 @@ export function createToolRegistry(args: {
     managers,
     skillContext,
     availableCategories,
+    builtinMcp,
     interactiveBashEnabled = isInteractiveBashEnabled(),
     toolFactories,
   } = args
@@ -216,6 +219,7 @@ export function createToolRegistry(args: {
     manager: managers.skillMcpManager,
     getLoadedSkills: () => skillContext.mergedSkills,
     getSessionID: getSessionIDForMcp,
+    builtinMcp,
   })
 
   const commands = factories.discoverCommandsSync(ctx.directory, {

package/src/tools/skill-mcp/tools.ts

@@ -1,14 +1,17 @@
 import { tool, type ToolDefinition } from "@opencode-ai/plugin"
 import type { ToolContext } from "@opencode-ai/plugin/tool"
 import { BUILTIN_MCP_TOOL_HINTS, SKILL_MCP_DESCRIPTION } from "./constants"
+import type { McpServerConfig } from "../../config/types"
 import type { SkillMcpArgs } from "./types"
 import type { SkillMcpManager, SkillMcpClientInfo, SkillMcpServerContext } from "../../features/skill-mcp-manager"
+import type { ClaudeCodeMcpServer } from "../../features/claude-code-mcp-loader/types"
 import type { LoadedSkill } from "../../features/opencode-skill-loader/types"
 
 interface SkillMcpToolOptions {
   manager: SkillMcpManager
   getLoadedSkills: () => LoadedSkill[]
   getSessionID?: () => string | undefined
+  builtinMcp?: Record<string, McpServerConfig>
 }
 
 type OperationType = { type: "tool" | "resource" | "prompt"; name: string }
@@ -60,6 +63,28 @@ function findMcpServer(
   return null
 }
 
+function convertBuiltinMcpConfig(config: McpServerConfig): ClaudeCodeMcpServer | null {
+  if (config.enabled === false) return null
+
+  if (config.type === "remote") {
+    return {
+      type: "http",
+      url: config.url,
+      headers: config.headers,
+    }
+  }
+
+  const [command, ...args] = config.command ?? []
+  if (!command) return null
+
+  return {
+    type: "stdio",
+    command,
+    args,
+    env: config.environment,
+  }
+}
+
 function formatAvailableMcps(skills: LoadedSkill[]): string {
   const mcps: string[] = []
   for (const skill of skills) {
@@ -72,6 +97,14 @@ function formatAvailableMcps(skills: LoadedSkill[]): string {
   return mcps.length > 0 ? mcps.join("\n") : "  (none found)"
 }
 
+function formatAvailableBuiltinMcps(builtinMcp: Record<string, McpServerConfig> | undefined): string {
+  const names = Object.entries(builtinMcp ?? {})
+    .filter(([, config]) => config.enabled !== false)
+    .map(([name]) => `  - "${name}" from hiai-opencode config`)
+
+  return names.length > 0 ? names.join("\n") : "  (none found)"
+}
+
 function formatBuiltinMcpHint(mcpName: string): string | null {
   const nativeTools = BUILTIN_MCP_TOOL_HINTS[mcpName]
   if (!nativeTools) return null
@@ -119,7 +152,7 @@ export function applyGrepFilter(output: string, pattern: string | undefined): st
 }
 
 export function createSkillMcpTool(options: SkillMcpToolOptions): ToolDefinition {
-  const { manager, getLoadedSkills, getSessionID } = options
+  const { manager, getLoadedSkills, getSessionID, builtinMcp } = options
 
   return tool({
     description: SKILL_MCP_DESCRIPTION,
@@ -141,8 +174,10 @@ export function createSkillMcpTool(options: SkillMcpToolOptions): ToolDefinition
       const operation = validateOperationParams(args)
       const skills = getLoadedSkills()
       const found = findMcpServer(args.mcp_name, skills)
+      const builtinConfig = builtinMcp?.[args.mcp_name]
+      const convertedBuiltinConfig = builtinConfig ? convertBuiltinMcpConfig(builtinConfig) : null
 
-      if (!found) {
+      if (!found && !convertedBuiltinConfig) {
         const builtinHint = formatBuiltinMcpHint(args.mcp_name)
         if (builtinHint) {
           throw new Error(builtinHint)
@@ -153,7 +188,10 @@ export function createSkillMcpTool(options: SkillMcpToolOptions): ToolDefinition
             `Available MCP servers in loaded skills:\n` +
             formatAvailableMcps(skills) +
             `\n\n` +
-            `Hint: Load the skill first using the 'skill' tool, then call skill_mcp.`,
+            `Available MCP servers in hiai-opencode config:\n` +
+            formatAvailableBuiltinMcps(builtinMcp) +
+            `\n\n` +
+            `Hint: Load the skill first for skill-embedded MCPs. Builtin hiai-opencode MCPs can be called directly when enabled in hiai-opencode.json.`,
         )
       }
 
@@ -164,14 +202,14 @@ export function createSkillMcpTool(options: SkillMcpToolOptions): ToolDefinition
 
       const info: SkillMcpClientInfo = {
         serverName: args.mcp_name,
-        skillName: found.skill.name,
+        skillName: found?.skill.name ?? "hiai-opencode",
         sessionID,
-        scope: found.skill.scope,
+        scope: found?.skill.scope ?? "user",
       }
 
       const context: SkillMcpServerContext = {
-        config: found.config,
-        skillName: found.skill.name,
+        config: found?.config ?? convertedBuiltinConfig!,
+        skillName: found?.skill.name ?? "hiai-opencode",
       }
 
       const parsedArgs = parseArguments(args.arguments)