@hiai-gg/hiai-opencode 0.1.5 → 0.1.7

package/src/tools/delegate-task/model-string-parser.test.ts

@@ -0,0 +1,90 @@
+import { expect, test, describe } from "bun:test"
+import { parseModelString, parseVariantFromModelID } from "./model-string-parser"
+
+describe("parseModelString", () => {
+  test("parses model with variant", () => {
+    const result = parseModelString("openai/gpt-5.3-codex medium")
+    expect(result?.modelID).toBe("gpt-5.3-codex")
+    expect(result?.providerID).toBe("openai")
+    expect(result?.variant).toBe("medium")
+  })
+
+  test("parses model without variant", () => {
+    const result = parseModelString("openai/gpt-5.3-codex")
+    expect(result?.modelID).toBe("gpt-5.3-codex")
+    expect(result?.providerID).toBe("openai")
+    expect(result?.variant).toBeUndefined()
+  })
+
+  test("handles whitespace trimming", () => {
+    const result = parseModelString("  openai/gpt-5.3-codex  high  ")
+    expect(result?.modelID).toBe("gpt-5.3-codex")
+    expect(result?.variant).toBe("high")
+  })
+
+  test("handles empty string", () => {
+    const result = parseModelString("")
+    expect(result).toBeUndefined()
+  })
+
+  test("handles model with multiple spaces before variant", () => {
+    const result = parseModelString("anthropic/claude-3.5-sonnet  high")
+    expect(result?.modelID).toBe("claude-3.5-sonnet")
+    expect(result?.variant).toBe("high")
+  })
+
+  test("handles provider/model with multiple slashes", () => {
+    const result = parseModelString("openrouter/anthropic/claude-3.5-sonnet ultra")
+    expect(result?.providerID).toBe("openrouter")
+    expect(result?.modelID).toBe("anthropic/claude-3.5-sonnet ultra")
+  })
+
+  test("returns model when no variant", () => {
+    const result = parseModelString("openrouter/google/gemini-2.0-flash")
+    expect(result?.modelID).toBe("google/gemini-2.0-flash")
+    expect(result?.providerID).toBe("openrouter")
+    expect(result?.variant).toBeUndefined()
+  })
+
+  test("single slash model returns undefined", () => {
+    const result = parseModelString("claude-medium")
+    expect(result).toBeUndefined()
+  })
+
+  test("model with xhigh variant", () => {
+    const result = parseModelString("openai/gpt-5.3-codex xhigh")
+    expect(result?.modelID).toBe("gpt-5.3-codex")
+    expect(result?.variant).toBe("xhigh")
+  })
+
+  test("model with max variant", () => {
+    const result = parseModelString("anthropic/claude-3.5-opus max")
+    expect(result?.modelID).toBe("claude-3.5-opus")
+    expect(result?.variant).toBe("max")
+  })
+})
+
+describe("parseVariantFromModelID", () => {
+  test("extracts parenthesized variant", () => {
+    const result = parseVariantFromModelID("gpt-5.3-codex (medium)")
+    expect(result.modelID).toBe("gpt-5.3-codex")
+    expect(result.variant).toBe("medium")
+  })
+
+  test("extracts space variant", () => {
+    const result = parseVariantFromModelID("gpt-5.3-codex medium")
+    expect(result.modelID).toBe("gpt-5.3-codex")
+    expect(result.variant).toBe("medium")
+  })
+
+  test("no variant when not recognized", () => {
+    const result = parseVariantFromModelID("gpt-5.3-codex unknownvariant")
+    expect(result.modelID).toBe("gpt-5.3-codex unknownvariant")
+    expect(result.variant).toBeUndefined()
+  })
+
+  test("handles empty string", () => {
+    const result = parseVariantFromModelID("")
+    expect(result.modelID).toBe("")
+  })
+})

package/src/tools/delegate-task/openai-categories.ts

@@ -1,29 +1,33 @@
 import type { BuiltinCategoryDefinition } from "./builtin-category-definition"
 
 const ULTRABRAIN_CATEGORY_PROMPT_APPEND = `<Category_Context>
-You are working on DEEP LOGICAL REASONING / COMPLEX ARCHITECTURE tasks.
+You are working on DEEP LOGICAL REASONING / ARCHITECTURE / STRATEGY tasks.
 
 <Routing_Policy>
-Executor contour: coder (deep execution). Do not use this category for bounded quick edits.
+Executor contour: strategist (plan + analysis, read-only). This category produces a structured plan, NOT implementation. The caller is responsible for routing the implementation step to \`deep\`, \`bounded\`, or \`cross-module\` mode based on your plan.
 </Routing_Policy>
 
-**CRITICAL - CODE STYLE REQUIREMENTS (NON-NEGOTIABLE)**:
-1. BEFORE writing ANY code, SEARCH the existing codebase to find similar patterns/styles
-2. Your code MUST match the project's existing conventions - blend in seamlessly
-3. Write READABLE code that humans can easily understand - no clever tricks
-4. If unsure about style, explore more files until you find the pattern
-
-Strategic advisor mindset:
-- Bias toward simplicity: least complex solution that fulfills requirements
-- Leverage existing code/patterns over new components
-- Prioritize developer experience and maintainability
-- One clear recommendation with effort estimate (Quick/Short/Medium/Large)
-- Signal when advanced approach warranted
-
-Response format:
-- Bottom line (2-3 sentences)
-- Action plan (numbered steps)
-- Risks and mitigations (if relevant)
+<Output_Contract>
+Your output MUST contain:
+1. **Decomposition** - concrete tasks with bounded scope (each task small enough that one executor agent can complete it without further planning).
+2. **Dependency graph** - which tasks block which; identify parallel-safe tasks explicitly.
+3. **Tradeoffs** - at least 2 alternative approaches with cost/risk for each; recommend one and justify briefly.
+4. **Recommended next step** - explicit \`task(category=...)\` call the caller should make to start implementation.
+5. **Open questions** - assumptions the caller should confirm before kickoff (if any).
+
+You MUST NOT:
+- Write or edit code (you have no write/edit tools).
+- Mark task as done yourself; the caller verifies the plan and routes implementation.
+- Defer planning by asking clarifying questions when assumptions can be stated and surfaced as Open questions.
+</Output_Contract>
+
+<Reasoning_Discipline>
+- Bias toward simplicity: least complex solution that fulfills requirements.
+- Leverage existing code/patterns over new components - reference concrete files when relevant.
+- Surface assumptions explicitly as Open questions rather than guessing silently.
+- For unfamiliar domains, recommend a \`task(subagent_type="researcher", run_in_background=true, ...)\` exploration step before planning.
+- One clear recommendation with effort estimate (Quick / Short / Medium / Large).
+</Reasoning_Discipline>
 </Category_Context>`
 
 const DEEP_CATEGORY_PROMPT_APPEND = `<Category_Context>
@@ -55,7 +59,7 @@ const QUICK_CATEGORY_PROMPT_APPEND = `<Category_Context>
 You are working on SMALL / QUICK tasks.
 
 <Routing_Policy>
-Executor contour: coder (fast bounded execution). Keep the implementation narrow and escalate only when the task truly becomes deep or cross-system.
+Executor contour: sub (cheap fast-tier executor). Keep the implementation narrow and escalate only when the task truly becomes deep or cross-system.
 </Routing_Policy>
 
 Efficient execution mindset:
@@ -110,7 +114,7 @@ export const OPENAI_CATEGORIES: BuiltinCategoryDefinition[] = [
   {
     name: "ultrabrain",
     config: {},
-    description: "Hard logic and architecture tasks. Uses coder execution contour; avoid for quick bounded edits.",
+    description: "Hard logic, architecture, strategy. Returns structured plan (decomposition + dependency graph + tradeoffs), NOT implementation. Follow up with deep/bounded/cross-module mode for build.",
     promptAppend: ULTRABRAIN_CATEGORY_PROMPT_APPEND,
   },
   {
@@ -122,7 +126,7 @@ export const OPENAI_CATEGORIES: BuiltinCategoryDefinition[] = [
   {
     name: "quick",
     config: {},
-    description: "Fast bounded execution: single-file fixes, typos, and simple modifications. Uses coder execution contour.",
+    description: "Fast bounded execution: single-file fixes, typos, and simple modifications. Uses sub (cheap fast-tier) execution contour.",
     promptAppend: QUICK_CATEGORY_PROMPT_APPEND,
   },
 ]

package/src/tools/delegate-task/sub-agent.ts

@@ -21,6 +21,7 @@ export const CANONICAL_DELEGATE_AGENT_KEYS = [
 ] as const
 
 type CanonicalDelegateAgentKey = (typeof CANONICAL_DELEGATE_AGENT_KEYS)[number]
+export type { CanonicalDelegateAgentKey }
 const CANONICAL_DELEGATE_AGENT_KEY_SET = new Set<string>(CANONICAL_DELEGATE_AGENT_KEYS)
 
 const LEGACY_DELEGATE_AGENT_ALIASES: Record<string, CanonicalDelegateAgentKey> = {
@@ -44,8 +45,17 @@ const LEGACY_DELEGATE_AGENT_ALIASES: Record<string, CanonicalDelegateAgentKey> =
   "project-initializer": "platform-manager",
   mindmodel: "platform-manager",
   ui: "multimodal",
+  writer: "brainstormer",
+  copywriter: "brainstormer",
+  "content-writer": "brainstormer",
   subagent: "sub",
   "bob-junior": "sub",
+  oracle: "strategist",
+  hephaestus: "coder",
+  metis: "strategist",
+  momus: "critic",
+  "sisyphus-junior": "sub",
+  "multimodal-looker": "multimodal",
 }
 
 export function resolveCanonicalDelegateAgentKey(agentName: string): string {

package/src/tools/delegate-task/subagent-discovery.test.ts

@@ -0,0 +1,123 @@
+import { expect, test, describe } from "bun:test"
+import { sanitizeSubagentType, findPrimaryAgentMatch, findCallableAgentMatch, listCallableAgentNames, isTaskCallableAgentMode } from "./subagent-discovery"
+
+describe("sanitizeSubagentType", () => {
+  test("trims whitespace", () => {
+    expect(sanitizeSubagentType("  researcher  ")).toBe("researcher")
+  })
+
+  test("removes surrounding quotes", () => {
+    expect(sanitizeSubagentType('"researcher"')).toBe("researcher")
+    expect(sanitizeSubagentType("'researcher'")).toBe("researcher")
+  })
+
+  test("removes surrounding slashes", () => {
+    expect(sanitizeSubagentType("/researcher/")).toBe("researcher")
+  })
+
+  test("removes backslashes", () => {
+    expect(sanitizeSubagentType("\\researcher\\")).toBe("researcher")
+  })
+
+  test("handles mixed characters", () => {
+    expect(sanitizeSubagentType('  /"researcher"\\ ')).toBe("researcher")
+  })
+})
+
+describe("isTaskCallableAgentMode", () => {
+  test("returns true for subagent mode", () => {
+    expect(isTaskCallableAgentMode("subagent")).toBe(true)
+  })
+
+  test("returns true for all mode", () => {
+    expect(isTaskCallableAgentMode("all")).toBe(true)
+  })
+
+  test("returns false for primary mode", () => {
+    expect(isTaskCallableAgentMode("primary")).toBe(false)
+  })
+
+  test("returns false for undefined", () => {
+    expect(isTaskCallableAgentMode(undefined)).toBe(false)
+  })
+})
+
+describe("findPrimaryAgentMatch", () => {
+  const agents = [
+    { name: "Bob", mode: "primary" as const, model: "openrouter/test/bob" },
+    { name: "Coder", mode: "primary" as const, model: "openrouter/test/coder" },
+    { name: "Researcher", mode: "primary" as const, model: "openrouter/test/researcher" },
+    { name: "SubAgent", mode: "subagent" as const, model: "openrouter/test/sub" },
+  ]
+
+  test("finds primary agent by exact name", () => {
+    const result = findPrimaryAgentMatch(agents, "Bob")
+    expect(result?.name).toBe("Bob")
+  })
+
+  test("finds primary agent by canonical key", () => {
+    const result = findPrimaryAgentMatch(agents, "researcher")
+    expect(result?.name).toBe("Researcher")
+  })
+
+  test("returns undefined for non-existent agent", () => {
+    const result = findPrimaryAgentMatch(agents, "Nonexistent")
+    expect(result).toBeUndefined()
+  })
+
+  test("returns undefined when searching for subagent mode", () => {
+    const result = findPrimaryAgentMatch(agents, "SubAgent")
+    expect(result).toBeUndefined()
+  })
+})
+
+describe("findCallableAgentMatch", () => {
+  const agents = [
+    { name: "Bob", mode: "primary" as const, model: "openrouter/test/bob" },
+    { name: "Coder", mode: "primary" as const, model: "openrouter/test/coder" },
+    { name: "Researcher", mode: "subagent" as const, model: "openrouter/test/researcher" },
+    { name: "SubAgent", mode: "subagent" as const, model: "openrouter/test/sub" },
+    { name: "Vision", mode: "all" as const, model: "openrouter/test/vision" },
+  ]
+
+  test("finds callable agent by subagent mode", () => {
+    const result = findCallableAgentMatch(agents, "SubAgent")
+    expect(result?.name).toBe("SubAgent")
+  })
+
+  test("finds callable agent by all mode", () => {
+    const result = findCallableAgentMatch(agents, "Vision")
+    expect(result?.name).toBe("Vision")
+  })
+
+  test("finds callable agent by canonical researcher (subagent mode)", () => {
+    const result = findCallableAgentMatch(agents, "researcher")
+    expect(result?.name).toBe("Researcher")
+  })
+
+  test("returns undefined for primary-only agent", () => {
+    const result = findCallableAgentMatch(agents, "Bob")
+    expect(result).toBeUndefined()
+  })
+})
+
+describe("listCallableAgentNames", () => {
+  test("lists callable agents sorted alphabetically (subagent and all modes)", () => {
+    const agents = [
+      { name: "Vision", mode: "all" as const },
+      { name: "Researcher", mode: "subagent" as const },
+      { name: "Bob", mode: "primary" as const },
+    ]
+    const result = listCallableAgentNames(agents)
+    expect(result).toBe("Researcher, Vision")
+  })
+
+  test("returns empty string for no callable agents", () => {
+    const agents = [
+      { name: "Bob", mode: "primary" as const },
+      { name: "Coder", mode: "primary" as const },
+    ]
+    const result = listCallableAgentNames(agents)
+    expect(result).toBe("")
+  })
+})

package/src/tools/delegate-task/subagent-resolver.ts

@@ -73,6 +73,23 @@ Create the work plan directly - that's your job as the planning agent.`,
     }
   }
 
+  const ORCHESTRATOR_AGENTS: Set<string> = new Set(["bob"])
+  if (ORCHESTRATOR_AGENTS.has(requestedCanonicalAgentKey)) {
+    return {
+      agentToUse: "",
+      categoryModel: undefined,
+      error: `Cannot delegate to orchestrator agent "${requestedCanonicalAgentKey}". Bob is the entry-point orchestrator and is not callable as a subagent. Use a specific subagent (researcher/strategist/coder/...) or a mode (quick/deep/...).`,
+    }
+  }
+
+  if (canonicalParentAgent && canonicalParentAgent === requestedCanonicalAgentKey) {
+    return {
+      agentToUse: "",
+      categoryModel: undefined,
+      error: `Self-delegation not allowed: agent "${requestedCanonicalAgentKey}" cannot delegate to itself via task. Continue the work directly or use session_id=... to continue an existing subagent session.`,
+    }
+  }
+
   let agentToUse = requestedAgentName
   let categoryModel: DelegatedModelConfig | undefined
   let fallbackChain: FallbackEntry[] | undefined = undefined
@@ -84,8 +101,8 @@ Create the work plan directly - that's your job as the planning agent.`,
     })
 
     const mergedAgents = mergeWithClaudeCodeAgents(agents, executorCtx.directory)
-    const matchedPrimaryAgent = findPrimaryAgentMatch(mergedAgents, agentToUse)
 
+    const matchedPrimaryAgent = findPrimaryAgentMatch(mergedAgents, agentToUse)
     if (matchedPrimaryAgent) {
       return {
         agentToUse: "",

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

@@ -1,6 +1,6 @@
 export const SKILL_MCP_TOOL_NAME = "skill_mcp"
 
-export const SKILL_MCP_DESCRIPTION = `Invoke MCP server operations from skill-embedded MCPs. Requires mcp_name plus exactly one of: tool_name, resource_name, or prompt_name.`
+export const SKILL_MCP_DESCRIPTION = `Invoke MCP server operations from skill-embedded MCPs or enabled hiai-opencode builtin MCPs. Requires mcp_name plus exactly one of: tool_name, resource_name, or prompt_name.`
 
 export const BUILTIN_MCP_TOOL_HINTS: Record<string, string[]> = {
   context7: ["context7_resolve-library-id", "context7_query-docs"],

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

@@ -0,0 +1,44 @@
+import { expect, test } from "bun:test"
+import type { ToolContext } from "@opencode-ai/plugin/tool"
+
+import { createSkillMcpTool } from "./tools"
+
+test("skill_mcp falls back to enabled builtin MCP when skill MCP is absent", async () => {
+  let callCaptured: { serverName: string; toolName: string } | null = null
+
+  const toolDef = createSkillMcpTool({
+    manager: {
+      async callTool(info, _context, toolName) {
+        callCaptured = { serverName: info.serverName, toolName }
+        return { ok: true }
+      },
+      async readResource() {
+        return { ok: true }
+      },
+      async getPrompt() {
+        return { ok: true }
+      },
+    } as any,
+    getLoadedSkills: () => [],
+    getSessionID: () => "session-test",
+    builtinMcp: {
+      firecrawl: {
+        enabled: true,
+        type: "local",
+        command: ["node", "firecrawl.mjs"],
+      },
+    },
+  })
+
+  const result = await toolDef.execute(
+    {
+      mcp_name: "firecrawl",
+      tool_name: "firecrawl_search",
+      arguments: { query: "test" },
+    } as any,
+    { sessionID: "session-test" } as ToolContext,
+  )
+
+  expect(callCaptured).toEqual({ serverName: "firecrawl", toolName: "firecrawl_search" })
+  expect(result).toContain("\"ok\": true")
+})

package/dist/config/loader.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/config/models.d.ts

@@ -1,13 +0,0 @@
-export declare const MODEL_ROLE_GUIDE: readonly ["fast: cheap/default for bounded helpers, researcher-style scans, platform chores", "mid: balanced default for steady execution/review work", "high: stronger general-purpose model for primary implementation and planning", "ultrahigh: highest-cost/high-accuracy slot for hard architecture or critical decisions", "vision: preferred for UI/media/multimodal interpretation and visual work", "reasoning: preferred for deeper multi-step reasoning when latency/cost are acceptable"];
-export declare const PROVIDER_MODEL_RULES: readonly ["openai: use `openai/<model>` for direct OpenAI calls, e.g. `openai/gpt-5` or `openai/o1`", "anthropic: use `anthropic/<model>`, e.g. `anthropic/claude-3.5-sonnet`", "deepseek: use `deepseek/<model>` when connected directly", "glm: use `z-ai/<model>` or the provider id exposed by your gateway/client", "minimax: use `minimax/<model>`", "qwen: use `qwen/<model>`", "ollama: use the native local model id in Ollama config, e.g. `qwen3.5:4b`", "openrouter: use `openrouter/<vendor>/<model>`, e.g. `openrouter/anthropic/claude-3.5-sonnet`", "rule: store fully qualified model ids in config; avoid local aliases like `fast`, `sonnet`, or provider-less ids"];
-export declare const MODEL_PRESETS: {
-    readonly fast: "openrouter/google/gemini-2.0-flash";
-    readonly mid: "openrouter/anthropic/claude-3.5-sonnet";
-    readonly high: "openrouter/anthropic/claude-3.5-opus";
-    readonly ultrahigh: "openrouter/openai/gpt-4o";
-    readonly vision: "openrouter/google/gemini-2.0-pro-exp-02-05";
-    readonly reasoning: "openrouter/openai/o1";
-    readonly strategist: "openrouter/z-ai/glm-5.1";
-    readonly critic: "openrouter/qwen/qwen2.5-72b-instruct";
-    readonly writing: "openrouter/kimi/kimi-latest";
-};

package/dist/config/schema/websearch.d.ts

@@ -1,13 +0,0 @@
-import { z } from "zod";
-export declare const WebsearchProviderSchema: z.ZodEnum<{
-    exa: "exa";
-    tavily: "tavily";
-}>;
-export declare const WebsearchConfigSchema: z.ZodObject<{
-    provider: z.ZodOptional<z.ZodEnum<{
-        exa: "exa";
-        tavily: "tavily";
-    }>>;
-}, z.core.$strip>;
-export type WebsearchProvider = z.infer<typeof WebsearchProviderSchema>;
-export type WebsearchConfig = z.infer<typeof WebsearchConfigSchema>;

package/dist/hooks/no-bob-gpt/hook.d.ts

@@ -1,16 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-export declare function createNoBobGptHook(ctx: PluginInput): {
-    "chat.message": (input: {
-        sessionID: string;
-        agent?: string;
-        model?: {
-            providerID: string;
-            modelID: string;
-        };
-    }, output?: {
-        message?: {
-            agent?: string;
-            [key: string]: unknown;
-        };
-    }) => Promise<void>;
-};

package/dist/hooks/no-bob-gpt/index.d.ts

@@ -1 +0,0 @@
-export { createNoBobGptHook } from "./hook";

package/dist/hooks/no-coder-non-gpt/hook.d.ts

@@ -1,20 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-type NoCoderNonGptHookOptions = {
-    allowNonGptModel?: boolean;
-};
-export declare function createNoCoderNonGptHook(ctx: PluginInput, options?: NoCoderNonGptHookOptions): {
-    "chat.message": (input: {
-        sessionID: string;
-        agent?: string;
-        model?: {
-            providerID: string;
-            modelID: string;
-        };
-    }, output?: {
-        message?: {
-            agent?: string;
-            [key: string]: unknown;
-        };
-    }) => Promise<void>;
-};
-export {};

package/dist/hooks/no-coder-non-gpt/index.d.ts

@@ -1 +0,0 @@
-export { createNoCoderNonGptHook } from "./hook";

package/dist/internals/plugins/websearch-cited/google.d.ts

@@ -1,38 +0,0 @@
-import type { WebsearchClient } from "./types.ts";
-type GeminiChunkWeb = {
-    title?: string;
-    uri?: string;
-};
-type GeminiChunk = {
-    web?: GeminiChunkWeb;
-};
-type GeminiSupportSegment = {
-    startIndex?: number;
-    endIndex?: number;
-};
-type GeminiSupport = {
-    segment?: GeminiSupportSegment;
-    groundingChunkIndices?: number[];
-};
-type GeminiMetadata = {
-    groundingChunks?: GeminiChunk[];
-    groundingSupports?: GeminiSupport[];
-};
-type GeminiTextPart = {
-    text?: string;
-    thought?: unknown;
-};
-type GeminiContent = {
-    role?: string;
-    parts?: GeminiTextPart[];
-};
-type GeminiCandidate = {
-    content?: GeminiContent;
-    groundingMetadata?: GeminiMetadata;
-};
-type GeminiGenerateContentResponse = {
-    candidates?: GeminiCandidate[];
-};
-export declare function formatWebSearchResponse(response: GeminiGenerateContentResponse, query: string): string;
-export declare function createGoogleWebsearchClient(model: string): WebsearchClient;
-export {};

package/dist/internals/plugins/websearch-cited/index.d.ts

@@ -1,17 +0,0 @@
-import { type Plugin } from "@opencode-ai/plugin";
-import type { GetAuth } from "./types";
-export declare const GOOGLE_PROVIDER_ID = "google";
-export declare const OPENAI_PROVIDER_ID = "openai";
-export declare const OPENROUTER_PROVIDER_ID = "openrouter";
-type SelectedProviderID = typeof GOOGLE_PROVIDER_ID | typeof OPENAI_PROVIDER_ID | typeof OPENROUTER_PROVIDER_ID;
-export declare function registerGetAuth(providerID: string, getAuth: GetAuth): void;
-export declare function resolveGetAuth(providerID: string): GetAuth | undefined;
-type SelectedWebsearchConfig = {
-    providerID: SelectedProviderID;
-    model: string;
-};
-export type WebsearchCitedFallback = SelectedWebsearchConfig;
-declare const WebsearchCitedPlugin: (_ctx?: unknown, fallback?: WebsearchCitedFallback) => Promise<any>;
-export declare const WebsearchCitedGooglePlugin: Plugin;
-export declare const WebsearchCitedOpenAIPlugin: Plugin;
-export default WebsearchCitedPlugin;

package/dist/internals/plugins/websearch-cited/openai.d.ts

@@ -1,9 +0,0 @@
-import type { WebsearchClient } from "./types.ts";
-export type OpenAIWebsearchConfig = {
-    reasoningEffort?: string;
-    reasoningSummary?: string;
-    textVerbosity?: string;
-    store?: boolean;
-    include?: string[];
-};
-export declare function createOpenAIWebsearchClient(model: string, config: OpenAIWebsearchConfig): WebsearchClient;

package/dist/internals/plugins/websearch-cited/openrouter.d.ts

@@ -1,2 +0,0 @@
-import type { WebsearchClient } from "./types.ts";
-export declare function createOpenRouterWebsearchClient(model: string): WebsearchClient;

package/dist/internals/plugins/websearch-cited/types.d.ts

@@ -1,5 +0,0 @@
-import type { Auth as ProviderAuth } from "@opencode-ai/sdk";
-export type GetAuth = () => Promise<ProviderAuth | undefined>;
-export interface WebsearchClient {
-    search(query: string, abortSignal: AbortSignal, getAuth: GetAuth): Promise<string>;
-}

package/dist/mcp/grep-app.d.ts

@@ -1,6 +0,0 @@
-export declare const grep_app: {
-    type: "remote";
-    url: string;
-    enabled: boolean;
-    oauth: false;
-};

package/dist/mcp/omo-mcp-index.d.ts

@@ -1,10 +0,0 @@
-import type { HiaiOpenCodeConfig } from "../config/schema";
-export { McpNameSchema, type McpName } from "./types";
-type RemoteMcpConfig = {
-    type: "remote";
-    url: string;
-    enabled: boolean;
-    headers?: Record<string, string>;
-    oauth?: false;
-};
-export declare function createBuiltinMcps(disabledMcps?: string[], config?: HiaiOpenCodeConfig): Record<string, RemoteMcpConfig>;

package/dist/mcp/websearch.d.ts

@@ -1,11 +0,0 @@
-import type { WebsearchConfig } from "../config/schema";
-type RemoteMcpConfig = {
-    type: "remote";
-    url: string;
-    enabled: boolean;
-    headers?: Record<string, string>;
-    oauth?: false;
-};
-export declare function createWebsearchConfig(config?: WebsearchConfig): RemoteMcpConfig | undefined;
-export declare const websearch: RemoteMcpConfig | undefined;
-export {};

package/src/config/schema/websearch.ts

@@ -1,15 +0,0 @@
-import { z } from "zod"
-
-export const WebsearchProviderSchema = z.enum(["exa", "tavily"])
-
-export const WebsearchConfigSchema = z.object({
-  /**
-   * Websearch provider to use.
-   * - "exa": Uses Exa websearch (default, works without API key)
-   * - "tavily": Uses Tavily websearch (requires TAVILY_API_KEY)
-   */
-  provider: WebsearchProviderSchema.optional(),
-})
-
-export type WebsearchProvider = z.infer<typeof WebsearchProviderSchema>
-export type WebsearchConfig = z.infer<typeof WebsearchConfigSchema>