@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/config/defaults.ts

@@ -1,230 +0,0 @@
-/**
- * Runtime defaults for hiai-opencode.
- *
- * The user-facing config owns model choice through 10 primary agent slots.
- * Internal routing derives hidden agents and task categories from those slots.
- */
-import { existsSync, readFileSync } from "node:fs"
-import { dirname, join, normalize } from "node:path"
-import { createDefaultMcpConfig } from "../mcp/registry.js"
-import type { HiaiOpencodeConfig, LspServerConfig } from "./types.js"
-
-const REQUIRED_MODEL_SLOTS = [
-  "bob",
-  "coder",
-  "strategist",
-  "guard",
-  "critic",
-  "designer",
-  "researcher",
-  "manager",
-  "brainstormer",
-  "vision",
-  "sub",
-] as const
-
-type ModelSlot = (typeof REQUIRED_MODEL_SLOTS)[number]
-
-const DEFAULT_LSP: Record<string, LspServerConfig> = {
-  typescript: {
-    enabled: true,
-    command: ["typescript-language-server", "--stdio"],
-    extensions: [".ts", ".tsx", ".mts", ".cts"],
-  },
-  svelte: {
-    enabled: true,
-    command: ["svelteserver", "--stdio"],
-    extensions: [".svelte"],
-  },
-  eslint: {
-    enabled: true,
-    command: ["node", "{pluginRoot}/assets/runtime/npm-package-runner.mjs", "eslint-lsp", "--stdio"],
-    extensions: [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".svelte"],
-  },
-  bash: {
-    enabled: true,
-    command: ["node", "{pluginRoot}/assets/runtime/npm-package-runner.mjs", "bash-language-server", "start"],
-    extensions: [".sh", ".bash"],
-  },
-  pyright: {
-    enabled: true,
-    command: ["pyright-langserver", "--stdio"],
-    extensions: [".py"],
-  },
-}
-
-function findPluginRoot(): string {
-  const candidates = [
-    join(import.meta.dirname, "..", ".."),
-    join(import.meta.dirname, ".."),
-    join(import.meta.dirname, "..", ".."),
-    dirname(process.argv[1] ?? ""),
-    process.cwd(),
-  ]
-
-  for (const candidate of candidates) {
-    const root = normalize(candidate)
-    if (existsSync(join(root, "hiai-opencode.json"))) return root
-  }
-
-  throw new Error("[hiai-opencode] Cannot find bundled hiai-opencode.json. The package is incomplete.")
-}
-
-function expandPluginRootPlaceholders(value: unknown, pluginRoot: string): unknown {
-  if (typeof value === "string") return value.replaceAll("{pluginRoot}", pluginRoot)
-  if (Array.isArray(value)) return value.map((item) => expandPluginRootPlaceholders(item, pluginRoot))
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, entry]) => [key, expandPluginRootPlaceholders(entry, pluginRoot)]),
-    )
-  }
-  return value
-}
-
-function requireModelSlots(config: HiaiOpencodeConfig): Record<ModelSlot, string> {
-  const models = config.models ?? {}
-  const resolved = Object.fromEntries(
-    REQUIRED_MODEL_SLOTS.map((slot) => {
-      const value = models[slot]
-      const model = typeof value === "string" ? value : value?.model
-      return [slot, model?.trim() ?? ""]
-    }),
-  ) as Record<ModelSlot, string>
-
-  const missing = REQUIRED_MODEL_SLOTS.filter((slot) => !resolved[slot])
-  if (missing.length > 0) {
-    throw new Error(`[hiai-opencode] Missing required model slot(s) in hiai-opencode.json: ${missing.join(", ")}`)
-  }
-  return resolved
-}
-
-function deriveAgents(models: Record<ModelSlot, string>): HiaiOpencodeConfig["agents"] {
-  return {
-    bob: { model: models.bob },
-    coder: { model: models.coder },
-    strategist: { model: models.strategist },
-    guard: { model: models.guard },
-    critic: { model: models.critic },
-    designer: { model: models.designer },
-    researcher: { model: models.researcher },
-    "platform-manager": { model: models.manager },
-    brainstormer: { model: models.brainstormer },
-    multimodal: { model: models.vision },
-    sub: { model: models.sub },
-    "quality-guardian": { model: models.critic },
-    "agent-skills": { model: models.manager },
-  }
-}
-
-function deriveCategories(models: Record<ModelSlot, string>): Record<string, import("./types").CategoryConfig> {
-  const categories: Record<string, import("./types").CategoryConfig> = {}
-  const entries: [string, Record<string, unknown>][] = [
-    ["visual-engineering", { variant: "high" }],
-    ["artistry", { variant: "high" }],
-    ["ultrabrain", { variant: "xhigh" }],
-    ["deep", { variant: "medium" }],
-    ["quick", {}],
-    ["writing", {}],
-    ["git", {}],
-    ["unspecified-low", {}],
-    ["unspecified-high", { variant: "max" }],
-  ]
-  for (const [name, cfg] of entries) {
-    categories[name] = cfg as import("./types").CategoryConfig
-  }
-  return categories
-}
-
-function deriveMcp(config: HiaiOpencodeConfig): HiaiOpencodeConfig["mcp"] {
-  const defaults = createDefaultMcpConfig()
-  const userMcp = config.mcp ?? {}
-  return Object.fromEntries(
-    Object.entries(defaults).map(([name, entry]) => {
-      const override = userMcp[name] ?? {}
-      const merged = { ...entry, ...override }
-
-      if (name === "mempalace" && typeof merged.pythonPath === "string" && merged.pythonPath.trim()) {
-        merged.environment = {
-          ...(entry.environment ?? {}),
-          ...(merged.environment ?? {}),
-          MEMPALACE_PYTHON: merged.pythonPath.trim(),
-        }
-      }
-
-      if (name === "websearch") {
-        const provider = merged.provider === "tavily" ? "tavily" : "exa"
-        merged.provider = provider
-        merged.type = "remote"
-        if (provider === "tavily") {
-          merged.url = "https://mcp.tavily.com/mcp/"
-          merged.headers = { Authorization: "Bearer {env:TAVILY_API_KEY}" }
-        } else {
-          merged.url = "https://mcp.exa.ai/mcp?tools=web_search_exa"
-          merged.headers = { "x-api-key": "{env:EXA_API_KEY}" }
-        }
-      }
-
-      // Internal launcher hint; do not leak unknown keys into final OpenCode MCP server config.
-      delete merged.pythonPath
-
-      return [name, merged]
-    }),
-  )
-}
-
-function deriveLsp(config: HiaiOpencodeConfig): HiaiOpencodeConfig["lsp"] {
-  const userLsp = config.lsp ?? {}
-  return Object.fromEntries(
-    Object.entries(DEFAULT_LSP).map(([name, entry]) => {
-      const override = userLsp[name] ?? {}
-      return [name, { ...entry, ...override }]
-    }),
-  )
-}
-
-function materializeConfig(rawConfig: HiaiOpencodeConfig): HiaiOpencodeConfig {
-  const models = requireModelSlots(rawConfig)
-  return {
-    ...rawConfig,
-    agents: deriveAgents(models),
-    agentRequirements: {},
-    categories: deriveCategories(models),
-    categoryRequirements: {},
-    modelFamilies: [],
-    mcp: deriveMcp(rawConfig),
-    lsp: deriveLsp(rawConfig),
-    subtask2: {
-      replace_generic: true,
-      generic_return: null,
-      ...(rawConfig.subtask2 ?? {}),
-    },
-    skills: {
-      enabled: true,
-      disabled: [],
-      ...(rawConfig.skills ?? {}),
-    },
-    permissions: {
-      read: { "*": "allow", "*.env": "deny", "*.env.*": "deny", "*.env.example": "allow" },
-      edit: { "*": "allow" },
-      bash: { "*": "allow" },
-      deny_paths: ["**/backup/**", "**/secrets.*", "**/.env", "**/.env.*"],
-      ...(rawConfig.permissions ?? {}),
-    },
-  }
-}
-
-function loadBundledDefaultConfig(): HiaiOpencodeConfig {
-  const pluginRoot = findPluginRoot()
-  const configPath = join(pluginRoot, "hiai-opencode.json")
-  const raw = readFileSync(configPath, "utf-8")
-  const parsed = JSON.parse(raw) as HiaiOpencodeConfig
-  const materialized = materializeConfig(parsed)
-
-  return expandPluginRootPlaceholders(materialized, pluginRoot) as HiaiOpencodeConfig
-}
-
-export function applyModelSlots(config: HiaiOpencodeConfig): HiaiOpencodeConfig {
-  return materializeConfig(config)
-}
-
-export const defaultConfig: HiaiOpencodeConfig = loadBundledDefaultConfig()

package/src/config/hiai-opencode.schema.json

@@ -1,12 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "type": "object",
-  "properties": {
-    "agents": { "type": "object" },
-    "auth": { "type": "object" },
-    "ollama": { "type": "object" },
-    "mcp": { "type": "object" },
-    "lsp": { "type": "object" },
-    "subtask2": { "type": "object" }
-  }
-}

package/src/config/index.ts

@@ -1,65 +0,0 @@
-/**
- * hiai-opencode config barrel
- *
- * Re-exports both the original platform config types and the oh-my-openagent
- * config schema types. The canonical config type is HiaiOpenCodeConfig (uppercase C)
- * from the oh-my-openagent schema. HiaiOpencodeConfig (lowercase c) is kept as
- * a backward-compatible alias for the original platform config shape.
- */
-
-// Original platform config loading
-export { loadConfig, resolveEnvVars, resolveMcpEnv } from "./loader.js";
-export { HiaiOpencodeConfigSchema } from "./platform-schema.js";
-export { defaultConfig } from "./defaults.js";
-export type {
-  HiaiOpencodeConfig,
-  AgentConfig,
-  CategoryConfig,
-  McpServerConfig,
-  LspServerConfig,
-  Subtask2Config,
-  SkillsConfig as PlatformSkillsConfig,
-  PermissionsConfig as PlatformPermissionsConfig,
-} from "./types.js";
-
-// Oh-my-openagent config schema (canonical)
-export { HiaiOpenCodeConfigSchema } from "./schema/oh-my-opencode-config.js";
-export type { HiaiOpenCodeConfig } from "./schema/oh-my-opencode-config.js";
-
-// Agent types
-export type { AgentName } from "./schema/agent-names.js";
-export type { AgentOverrideConfig, AgentOverrides } from "./schema/agent-overrides.js";
-export type { BuiltinSkillName } from "./schema/agent-names.js";
-
-// Hook types
-export type { HookName } from "./schema/hooks.js";
-
-// Category types
-export type { CategoryConfig as OhMyCategoryConfig, CategoriesConfig, BuiltinCategoryName } from "./schema/categories.js";
-
-// MCP types
-export type { McpName, AnyMcpName } from "../mcp/types.js";
-
-// Command types
-export type { BuiltinCommandName } from "./schema/commands.js";
-
-// Tmux types
-export type { TmuxConfig, TmuxLayout, TmuxIsolation } from "./schema/tmux.js";
-
-// Skill types
-export type { SkillsConfig, SkillDefinition } from "./schema/skills.js";
-
-// Other config sub-types
-export type { BackgroundTaskConfig } from "./schema/background-task.js";
-export type { BabysittingConfig } from "./schema/babysitting.js";
-export type { ExperimentalConfig } from "./schema/experimental.js";
-export type { NotificationConfig } from "./schema/notification.js";
-export type { RuntimeFallbackConfig } from "./schema/runtime-fallback.js";
-export type { FallbackModelObject, FallbackModels } from "./schema/fallback-models.js";
-export type { BobAgentConfig } from "./schema/bob-agent.js";
-export type { StartWorkConfig } from "./schema/start-work.js";
-export type { RalphLoopConfig } from "./schema/ralph-loop.js";
-export type { DynamicContextPruningConfig } from "./schema/dynamic-context-pruning.js";
-export type { GitMasterConfig } from "./schema/git-master.js";
-export type { ModelCapabilitiesConfig } from "./schema/model-capabilities.js";
-export type { FastApplyConfig } from "./schema/fast-apply.js";

package/src/config/loader.test.ts

@@ -1,80 +0,0 @@
-import { expect, test } from "bun:test";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { loadConfig } from "./loader.js";
-
-function withTempProject(
-  config: unknown,
-  run: (projectDir: string) => void,
-): void {
-  const originalHome = process.env.HOME;
-  const projectDir = mkdtempSync(join(tmpdir(), "hiai-opencode-project-"));
-  const fakeHomeDir = mkdtempSync(join(tmpdir(), "hiai-opencode-home-"));
-
-  try {
-    process.env.HOME = fakeHomeDir;
-    writeFileSync(
-      join(projectDir, "hiai-opencode.json"),
-      JSON.stringify(config),
-      "utf-8",
-    );
-    run(projectDir);
-  } finally {
-    if (originalHome === undefined) delete process.env.HOME;
-    else process.env.HOME = originalHome;
-    rmSync(projectDir, { recursive: true, force: true });
-    rmSync(fakeHomeDir, { recursive: true, force: true });
-  }
-}
-
-const requiredModels = {
-  bob: { model: "openrouter/test/bob", recommended: "xhigh" },
-  coder: { model: "openrouter/test/coder", recommended: "high" },
-  strategist: { model: "openrouter/test/strategist", recommended: "high" },
-  guard: "openrouter/test/guard",
-  critic: "openrouter/test/critic",
-  designer: "openrouter/test/designer",
-  researcher: "openrouter/test/researcher",
-  manager: "openrouter/test/manager",
-  brainstormer: "openrouter/test/brainstormer",
-  vision: "openrouter/test/vision",
-};
-
-test("loadConfig accepts compact enabled-only LSP entries for builtin servers", () => {
-  withTempProject(
-    {
-      models: requiredModels,
-      lsp: {
-        typescript: {
-          enabled: true,
-        },
-      },
-    },
-    (projectDir) => {
-      const loaded = loadConfig(projectDir);
-      const tsServer = loaded.lsp?.typescript;
-
-      expect(tsServer).toBeDefined();
-      expect(tsServer?.command?.length).toBeGreaterThan(0);
-      expect(tsServer?.extensions).toContain(".ts");
-    },
-  );
-});
-
-test("loadConfig ignores unknown compact enabled-only LSP entries", () => {
-  withTempProject(
-    {
-      models: requiredModels,
-      lsp: {
-        "custom-server": {
-          enabled: true,
-        },
-      },
-    },
-    (projectDir) => {
-      const loaded = loadConfig(projectDir);
-      expect(loaded.lsp?.["custom-server"]).toBeUndefined();
-    },
-  );
-});

package/src/config/loader.ts

@@ -1,188 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { parse } from "jsonc-parser";
-import { HiaiOpencodeConfigSchema } from "./platform-schema.js";
-import { applyModelSlots, defaultConfig } from "./defaults.js";
-import {
-  LEGACY_AGENT_ALIAS_TO_CANONICAL,
-  type CanonicalAgentName,
-  type HiaiOpencodeConfig,
-} from "./types.js";
-
-const LEGACY_AGENT_ALIAS_LOOKUP = new Map<string, CanonicalAgentName>(
-  Object.entries(LEGACY_AGENT_ALIAS_TO_CANONICAL).map(([alias, canonical]) => [
-    alias.toLowerCase(),
-    canonical,
-  ]),
-);
-
-const BASE_CONFIG = normalizeAgentAliases(defaultConfig);
-
-const CONFIG_FILENAMES = [
-  "hiai-opencode.json",
-  "hiai-opencode.jsonc",
-];
-
-function deepMerge<T extends Record<string, unknown>>(base: T, override: Partial<T>): T {
-  const result = { ...base };
-  for (const key of Object.keys(override) as Array<keyof T>) {
-    const val = override[key];
-    if (
-      val !== null &&
-      val !== undefined &&
-      typeof val === "object" &&
-      !Array.isArray(val) &&
-      typeof base[key] === "object" &&
-      base[key] !== null &&
-      !Array.isArray(base[key])
-    ) {
-      result[key] = deepMerge(
-        base[key] as Record<string, unknown>,
-        val as Record<string, unknown>,
-      ) as T[keyof T];
-    } else if (val !== undefined) {
-      result[key] = val as T[keyof T];
-    }
-  }
-  return result;
-}
-
-function findConfigFile(searchDirs: string[]): string | null {
-  for (const dir of searchDirs) {
-    for (const filename of CONFIG_FILENAMES) {
-      const candidate = join(dir, filename);
-      if (existsSync(candidate)) return candidate;
-    }
-  }
-  return null;
-}
-
-function toCanonicalAgentName(name: string): string {
-  return LEGACY_AGENT_ALIAS_LOOKUP.get(name.toLowerCase()) ?? name;
-}
-
-function normalizeAgentKeyedRecord<T>(
-  record?: Record<string, T>,
-): Record<string, T> | undefined {
-  if (!record) return record;
-
-  const normalized: Record<string, T> = {};
-  const aliasEntries: Array<[string, T]> = [];
-
-  for (const [rawName, config] of Object.entries(record)) {
-    const canonicalName = toCanonicalAgentName(rawName);
-    if (canonicalName === rawName) {
-      normalized[rawName] = config;
-      continue;
-    }
-    aliasEntries.push([canonicalName, config]);
-  }
-
-  // Explicit canonical/custom entries win over deprecated aliases.
-  for (const [canonicalName, config] of aliasEntries) {
-    if (!(canonicalName in normalized)) {
-      normalized[canonicalName] = config;
-    }
-  }
-
-  return normalized;
-}
-
-function normalizeAgentAliases(config: HiaiOpencodeConfig): HiaiOpencodeConfig {
-  const normalizedAgents = normalizeAgentKeyedRecord(config.agents);
-  const normalizedRequirements = normalizeAgentKeyedRecord(
-    config.agentRequirements,
-  );
-
-  return {
-    ...config,
-    ...(normalizedAgents ? { agents: normalizedAgents } : {}),
-    ...(normalizedRequirements
-      ? { agentRequirements: normalizedRequirements }
-      : {}),
-  };
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-function normalizeCompactLspConfig(rawConfig: unknown): unknown {
-  if (!isRecord(rawConfig)) return rawConfig;
-  const rawLsp = rawConfig.lsp;
-  if (!isRecord(rawLsp)) return rawConfig;
-
-  const normalizedLsp: Record<string, unknown> = {};
-  const baseLsp = BASE_CONFIG.lsp ?? {};
-
-  for (const [serverId, rawEntry] of Object.entries(rawLsp)) {
-    if (!isRecord(rawEntry)) continue;
-
-    const normalizedEntry: Record<string, unknown> = { ...rawEntry };
-    const baseEntry = baseLsp[serverId];
-
-    if (!Array.isArray(normalizedEntry.command) && baseEntry?.command) {
-      normalizedEntry.command = [...baseEntry.command];
-    }
-
-    if (!Array.isArray(normalizedEntry.extensions) && baseEntry?.extensions) {
-      normalizedEntry.extensions = [...baseEntry.extensions];
-    }
-
-    if (Array.isArray(normalizedEntry.command) && Array.isArray(normalizedEntry.extensions)) {
-      normalizedLsp[serverId] = normalizedEntry;
-    }
-  }
-
-  return {
-    ...rawConfig,
-    lsp: normalizedLsp,
-  };
-}
-
-export function loadConfig(projectDir: string): HiaiOpencodeConfig {
-  const searchDirs = [
-    projectDir,
-    join(projectDir, ".opencode"),
-    join(process.env.HOME || "", ".config", "opencode"),
-  ];
-
-  const configPath = findConfigFile(searchDirs);
-
-  if (!configPath) return BASE_CONFIG;
-
-  const raw = readFileSync(configPath, "utf-8");
-  const parsed = parse(raw);
-  const normalizedParsed = normalizeCompactLspConfig(parsed);
-  const validated = HiaiOpencodeConfigSchema.parse(normalizedParsed);
-  const normalized = normalizeAgentAliases(validated);
-
-  const merged = deepMerge(
-    BASE_CONFIG as unknown as Record<string, unknown>,
-    normalized as unknown as Record<string, unknown>,
-  ) as HiaiOpencodeConfig;
-
-  return applyModelSlots(merged);
-}
-
-export function resolveEnvVars(value: string): string {
-  return value.replace(/\{env:([^}]+)\}/g, (_, expression) => {
-    const [key, fallback] = String(expression).split(":-", 2);
-    return process.env[key] || fallback || "";
-  });
-}
-
-export function resolveMcpEnv(config: HiaiOpencodeConfig): HiaiOpencodeConfig {
-  if (!config.mcp) return config;
-  const mcp = { ...config.mcp };
-  for (const [name, server] of Object.entries(mcp)) {
-    if (server.environment) {
-      const env: Record<string, string> = {};
-      for (const [k, v] of Object.entries(server.environment)) {
-        env[k] = resolveEnvVars(v);
-      }
-      mcp[name] = { ...server, environment: env };
-    }
-  }
-  return { ...config, mcp };
-}

package/src/config/model-slots-and-export.test.ts

@@ -1,73 +0,0 @@
-import { expect, test } from "bun:test"
-
-import { applyModelSlots } from "./defaults"
-import type { HiaiOpencodeConfig } from "./types"
-import { buildStaticMcpJson, MCP_EXPORT_MARKER } from "../shared/mcp-static-export"
-import { buildHiaiIntegrationPrimerSection } from "../agents/dynamic-agent-core-sections"
-
-const baseConfig: HiaiOpencodeConfig = {
-  models: {
-    bob: { model: "openrouter/test/bob", recommended: "xhigh" },
-    coder: { model: "openrouter/test/coder", recommended: "high" },
-    strategist: { model: "openrouter/test/strategist", recommended: "high" },
-    guard: { model: "openrouter/test/guard", recommended: "middle" },
-    critic: { model: "openrouter/test/critic", recommended: "high" },
-    designer: { model: "openrouter/test/designer", recommended: "design" },
-    researcher: { model: "openrouter/test/researcher", recommended: "fast" },
-    manager: { model: "openrouter/test/manager", recommended: "fast" },
-    brainstormer: { model: "openrouter/test/brainstormer", recommended: "writing" },
-    vision: { model: "openrouter/test/vision", recommended: "vision" },
-    sub: { model: "openrouter/test/sub", recommended: "fast" },
-  },
-  mcp: {
-    mempalace: { enabled: true, pythonPath: "/opt/venv/bin/python" },
-  },
-}
-
-test("model slots derive canonical agents and categories", () => {
-  const resolved = applyModelSlots(baseConfig)
-  expect(resolved.agents?.bob?.model).toBe("openrouter/test/bob")
-  expect(resolved.agents?.coder?.model).toBe("openrouter/test/coder")
-  expect(resolved.agents?.["platform-manager"]?.model).toBe("openrouter/test/manager")
-  expect(resolved.agents?.sub?.model).toBe("openrouter/test/sub")
-  expect(resolved.categories?.artistry?.variant).toBe("high")
-  expect(resolved.categories?.ultrabrain?.variant).toBe("xhigh")
-  expect(resolved.categories?.deep?.variant).toBe("medium")
-  expect(resolved.categories?.quick).toBeDefined()
-  expect(resolved.categories?.writing).toBeDefined()
-  expect(resolved.categories?.git).toBeDefined()
-})
-
-test("compact MCP mempalace pythonPath is materialized into environment", () => {
-  const resolved = applyModelSlots(baseConfig)
-  expect(resolved.mcp?.mempalace?.environment?.MEMPALACE_PYTHON).toBe("/opt/venv/bin/python")
-})
-
-test("static MCP export includes marker metadata and servers", () => {
-  const resolved = applyModelSlots(baseConfig)
-  const exported = buildStaticMcpJson(resolved)
-
-  expect(exported._meta?.generatedBy).toBe(MCP_EXPORT_MARKER)
-  expect(exported._meta?.version).toBe(1)
-  expect(exported.mcpServers.playwright).toBeDefined()
-  expect(exported.mcpServers.mempalace).toBeDefined()
-  expect(exported.mcpServers.websearch).toBeDefined()
-  expect(exported.mcpServers.grep_app).toBeDefined()
-})
-
-test("websearch MCP provider is selected from the MCP switchboard", () => {
-  const resolved = applyModelSlots({
-    ...baseConfig,
-    mcp: {
-      websearch: { enabled: true, provider: "tavily" },
-    },
-  })
-
-  expect(resolved.mcp?.websearch?.url).toBe("https://mcp.tavily.com/mcp/")
-  expect(resolved.mcp?.websearch?.headers?.Authorization).toBe("Bearer {env:TAVILY_API_KEY}")
-})
-
-test("integration primer does not request model provider API keys", () => {
-  const primer = buildHiaiIntegrationPrimerSection()
-  expect(primer).toContain("Do not ask for `OPENROUTER_API_KEY`, `OPENAI_API_KEY`, or `ANTHROPIC_API_KEY`")
-})