ummaya 0.2.4 → 0.2.5

package/tui/src/tools/ToolSearchTool/ccSupportTools.ts

@@ -0,0 +1,223 @@
+/* eslint-disable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
+import { feature } from 'bun:bundle'
+import type { Tool, Tools } from '../../Tool.js'
+import { isAgentSwarmsEnabled } from '../../utils/agentSwarmsEnabled.js'
+import { hasEmbeddedSearchTools } from '../../utils/embeddedTools.js'
+import { isEnvTruthy } from '../../utils/envUtils.js'
+import { isPowerShellToolEnabled } from '../../utils/shell/shellToolUtils.js'
+import { isTodoV2Enabled } from '../../utils/tasks.js'
+import { isWorktreeModeEnabled } from '../../utils/worktreeModeEnabled.js'
+import { AgentTool } from '../AgentTool/AgentTool.js'
+import { AskUserQuestionTool } from '../AskUserQuestionTool/AskUserQuestionTool.js'
+import { BashTool } from '../BashTool/BashTool.js'
+import { BriefTool } from '../BriefTool/BriefTool.js'
+import { ConfigTool } from '../ConfigTool/ConfigTool.js'
+import { EnterPlanModeTool } from '../EnterPlanModeTool/EnterPlanModeTool.js'
+import { EnterWorktreeTool } from '../EnterWorktreeTool/EnterWorktreeTool.js'
+import { ExitPlanModeV2Tool } from '../ExitPlanModeTool/ExitPlanModeV2Tool.js'
+import { ExitWorktreeTool } from '../ExitWorktreeTool/ExitWorktreeTool.js'
+import { FileEditTool } from '../FileEditTool/FileEditTool.js'
+import { FileReadTool } from '../FileReadTool/FileReadTool.js'
+import { FileWriteTool } from '../FileWriteTool/FileWriteTool.js'
+import { GlobTool } from '../GlobTool/GlobTool.js'
+import { GrepTool } from '../GrepTool/GrepTool.js'
+import { LSPTool } from '../LSPTool/LSPTool.js'
+import { ListMcpResourcesTool } from '../ListMcpResourcesTool/ListMcpResourcesTool.js'
+import { NotebookEditTool } from '../NotebookEditTool/NotebookEditTool.js'
+import { ReadMcpResourceTool } from '../ReadMcpResourceTool/ReadMcpResourceTool.js'
+import {
+  REPL_TOOL_NAME,
+  REPL_ONLY_TOOLS,
+  isReplModeEnabled,
+} from '../REPLTool/constants.js'
+import { SkillTool } from '../SkillTool/SkillTool.js'
+import { TaskCreateTool } from '../TaskCreateTool/TaskCreateTool.js'
+import { TaskGetTool } from '../TaskGetTool/TaskGetTool.js'
+import { TaskListTool } from '../TaskListTool/TaskListTool.js'
+import { TaskOutputTool } from '../TaskOutputTool/TaskOutputTool.js'
+import { TaskStopTool } from '../TaskStopTool/TaskStopTool.js'
+import { TaskUpdateTool } from '../TaskUpdateTool/TaskUpdateTool.js'
+import { TodoWriteTool } from '../TodoWriteTool/TodoWriteTool.js'
+import { TungstenTool } from '../TungstenTool/TungstenTool.js'
+import { WebFetchTool } from '../WebFetchTool/WebFetchTool.js'
+import { WebSearchTool } from '../WebSearchTool/WebSearchTool.js'
+import { TestingPermissionTool } from '../testing/TestingPermissionTool.js'
+
+export { REPL_ONLY_TOOLS, REPL_TOOL_NAME, isReplModeEnabled }
+
+const CC_SUPPORT_TOOLS_ENV = 'UMMAYA_ENABLE_CC_SUPPORT_TOOLS'
+
+const REPLTool =
+  process.env.USER_TYPE === 'ant'
+    ? require('../REPLTool/REPLTool.js').REPLTool
+    : null
+const SuggestBackgroundPRTool =
+  process.env.USER_TYPE === 'ant'
+    ? require('../SuggestBackgroundPRTool/SuggestBackgroundPRTool.js')
+        .SuggestBackgroundPRTool
+    : null
+const SleepTool =
+  feature('PROACTIVE') || feature('KAIROS')
+    ? require('../SleepTool/SleepTool.js').SleepTool
+    : null
+const cronTools = feature('AGENT_TRIGGERS')
+  ? [
+      require('../ScheduleCronTool/CronCreateTool.js').CronCreateTool,
+      require('../ScheduleCronTool/CronDeleteTool.js').CronDeleteTool,
+      require('../ScheduleCronTool/CronListTool.js').CronListTool,
+    ]
+  : []
+const RemoteTriggerTool = feature('AGENT_TRIGGERS_REMOTE')
+  ? require('../RemoteTriggerTool/RemoteTriggerTool.js').RemoteTriggerTool
+  : null
+const MonitorTool = feature('MONITOR_TOOL')
+  ? require('../MonitorTool/MonitorTool.js').MonitorTool
+  : null
+const SendUserFileTool = feature('KAIROS')
+  ? require('../SendUserFileTool/SendUserFileTool.js').SendUserFileTool
+  : null
+const PushNotificationTool =
+  feature('KAIROS') || feature('KAIROS_PUSH_NOTIFICATION')
+    ? require('../PushNotificationTool/PushNotificationTool.js')
+        .PushNotificationTool
+    : null
+const SubscribePRTool = feature('KAIROS_GITHUB_WEBHOOKS')
+  ? require('../SubscribePRTool/SubscribePRTool.js').SubscribePRTool
+  : null
+const OverflowTestTool = feature('OVERFLOW_TEST_TOOL')
+  ? require('../OverflowTestTool/OverflowTestTool.js').OverflowTestTool
+  : null
+const CtxInspectTool = feature('CONTEXT_COLLAPSE')
+  ? require('../CtxInspectTool/CtxInspectTool.js').CtxInspectTool
+  : null
+const TerminalCaptureTool = feature('TERMINAL_PANEL')
+  ? require('../TerminalCaptureTool/TerminalCaptureTool.js').TerminalCaptureTool
+  : null
+const WebBrowserTool = feature('WEB_BROWSER_TOOL')
+  ? require('../WebBrowserTool/WebBrowserTool.js').WebBrowserTool
+  : null
+const coordinatorModeModule = feature('COORDINATOR_MODE')
+  ? require('../../coordinator/coordinatorMode.js')
+  : null
+const SnipTool = feature('HISTORY_SNIP')
+  ? require('../SnipTool/SnipTool.js').SnipTool
+  : null
+const ListPeersTool = feature('UDS_INBOX')
+  ? require('../ListPeersTool/ListPeersTool.js').ListPeersTool
+  : null
+const WorkflowTool = feature('WORKFLOW_SCRIPTS')
+  ? (() => {
+      require('../WorkflowTool/bundled/index.js').initBundledWorkflows()
+      return require('../WorkflowTool/WorkflowTool.js').WorkflowTool
+    })()
+  : null
+const VerifyPlanExecutionTool =
+  process.env.CLAUDE_CODE_VERIFY_PLAN === 'true'
+    ? require('../VerifyPlanExecutionTool/VerifyPlanExecutionTool.js')
+        .VerifyPlanExecutionTool
+    : null
+
+function getTeamCreateTool() {
+  return require('../TeamCreateTool/TeamCreateTool.js').TeamCreateTool
+}
+
+function getTeamDeleteTool() {
+  return require('../TeamDeleteTool/TeamDeleteTool.js').TeamDeleteTool
+}
+
+function getSendMessageTool() {
+  return require('../SendMessageTool/SendMessageTool.js').SendMessageTool
+}
+
+function getPowerShellTool() {
+  if (!isPowerShellToolEnabled()) return null
+  return require('../PowerShellTool/PowerShellTool.js').PowerShellTool
+}
+
+function asDeferredCcSupportTool(tool: Tool): Tool {
+  if (tool.alwaysLoad === true || tool.shouldDefer === true) return tool
+  return { ...tool, shouldDefer: true }
+}
+
+export function areCcSupportToolsEnabled(): boolean {
+  return process.env[CC_SUPPORT_TOOLS_ENV] !== '0'
+}
+
+export function getSupportSimpleModeTools(modelFacingTools: Tools): Tools {
+  if (isReplModeEnabled() && REPLTool && areCcSupportToolsEnabled()) {
+    const replSimple: Tool[] = [REPLTool]
+    if (
+      feature('COORDINATOR_MODE') &&
+      coordinatorModeModule?.isCoordinatorMode()
+    ) {
+      replSimple.push(TaskStopTool, getSendMessageTool())
+    }
+    return replSimple
+  }
+
+  const simpleTools: Tool[] = [...modelFacingTools]
+  if (
+    feature('COORDINATOR_MODE') &&
+    coordinatorModeModule?.isCoordinatorMode() &&
+    areCcSupportToolsEnabled()
+  ) {
+    simpleTools.push(AgentTool, TaskStopTool, getSendMessageTool())
+  }
+  return simpleTools
+}
+
+export function getCcSupportCapabilityTools(): Tools {
+  if (!areCcSupportToolsEnabled()) return []
+  const powerShellTool = getPowerShellTool()
+  return [
+    AgentTool,
+    TaskOutputTool,
+    BashTool,
+    ...(hasEmbeddedSearchTools() ? [] : [GlobTool, GrepTool]),
+    ExitPlanModeV2Tool,
+    FileReadTool,
+    FileEditTool,
+    FileWriteTool,
+    NotebookEditTool,
+    WebFetchTool,
+    TodoWriteTool,
+    WebSearchTool,
+    TaskStopTool,
+    AskUserQuestionTool,
+    SkillTool,
+    EnterPlanModeTool,
+    ...(process.env.USER_TYPE === 'ant' ? [ConfigTool, TungstenTool] : []),
+    ...(SuggestBackgroundPRTool ? [SuggestBackgroundPRTool] : []),
+    ...(WebBrowserTool ? [WebBrowserTool] : []),
+    ...(isTodoV2Enabled()
+      ? [TaskCreateTool, TaskGetTool, TaskUpdateTool, TaskListTool]
+      : []),
+    ...(OverflowTestTool ? [OverflowTestTool] : []),
+    ...(CtxInspectTool ? [CtxInspectTool] : []),
+    ...(TerminalCaptureTool ? [TerminalCaptureTool] : []),
+    ...(isEnvTruthy(process.env.ENABLE_LSP_TOOL) ? [LSPTool] : []),
+    ...(isWorktreeModeEnabled() ? [EnterWorktreeTool, ExitWorktreeTool] : []),
+    getSendMessageTool(),
+    ...(ListPeersTool ? [ListPeersTool] : []),
+    ...(isAgentSwarmsEnabled()
+      ? [getTeamCreateTool(), getTeamDeleteTool()]
+      : []),
+    ...(VerifyPlanExecutionTool ? [VerifyPlanExecutionTool] : []),
+    ...(process.env.USER_TYPE === 'ant' && REPLTool ? [REPLTool] : []),
+    ...(WorkflowTool ? [WorkflowTool] : []),
+    ...(SleepTool ? [SleepTool] : []),
+    ...cronTools,
+    ...(RemoteTriggerTool ? [RemoteTriggerTool] : []),
+    ...(MonitorTool ? [MonitorTool] : []),
+    BriefTool,
+    ...(SendUserFileTool ? [SendUserFileTool] : []),
+    ...(PushNotificationTool ? [PushNotificationTool] : []),
+    ...(SubscribePRTool ? [SubscribePRTool] : []),
+    ...(powerShellTool ? [powerShellTool] : []),
+    ...(SnipTool ? [SnipTool] : []),
+    ...(process.env.NODE_ENV === 'test' ? [TestingPermissionTool] : []),
+    ListMcpResourcesTool,
+    ReadMcpResourceTool,
+  ].map(asDeferredCcSupportTool)
+}
+/* eslint-enable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */

package/tui/src/tools/ToolSearchTool/descriptionCache.ts

@@ -0,0 +1,50 @@
+import memoize from 'lodash-es/memoize.js'
+import { findToolByName, type Tools } from '../../Tool.js'
+import { logForDebugging } from '../../utils/debug.js'
+
+let cachedDeferredToolNames: string | null = null
+
+function getDeferredToolsCacheKey(deferredTools: Tools): string {
+  return deferredTools
+    .map(tool => tool.name)
+    .sort()
+    .join(',')
+}
+
+export const getToolDescriptionMemoized = memoize(
+  async (toolName: string, tools: Tools): Promise<string> => {
+    const tool = findToolByName(tools, toolName)
+    if (!tool) {
+      return ''
+    }
+    return tool.prompt({
+      getToolPermissionContext: async () => ({
+        mode: 'default' as const,
+        additionalWorkingDirectories: new Map(),
+        alwaysAllowRules: {},
+        alwaysDenyRules: {},
+        alwaysAskRules: {},
+        isBypassPermissionsModeAvailable: false,
+      }),
+      tools,
+      agents: [],
+    })
+  },
+  (toolName: string) => toolName,
+)
+
+export function maybeInvalidateCache(deferredTools: Tools): void {
+  const currentKey = getDeferredToolsCacheKey(deferredTools)
+  if (cachedDeferredToolNames !== currentKey) {
+    logForDebugging(
+      `ToolSearchTool: cache invalidated - deferred tools changed`,
+    )
+    getToolDescriptionMemoized.cache.clear?.()
+    cachedDeferredToolNames = currentKey
+  }
+}
+
+export function clearToolSearchDescriptionCache(): void {
+  getToolDescriptionMemoized.cache.clear?.()
+  cachedDeferredToolNames = null
+}

package/tui/src/tools/ToolSearchTool/keywordSearch.ts

@@ -0,0 +1,216 @@
+import { findToolByName, type Tool, type Tools } from '../../Tool.js'
+import { escapeRegExp } from '../../utils/stringUtils.js'
+import { getToolDescriptionMemoized } from './descriptionCache.js'
+import {
+  expandedIntentTermSet,
+  expandedToolSearchTerms,
+} from './supportIntentHints.js'
+
+type ParsedToolName = {
+  readonly parts: readonly string[]
+  readonly full: string
+  readonly isMcp: boolean
+}
+
+type ScoredTool = {
+  readonly name: string
+  readonly score: number
+}
+
+function parseToolName(name: string): ParsedToolName {
+  if (name.startsWith('mcp__')) {
+    const withoutPrefix = name.replace(/^mcp__/, '').toLowerCase()
+    const parts = withoutPrefix.split('__').flatMap(part => part.split('_'))
+    return {
+      parts: parts.filter(Boolean),
+      full: withoutPrefix.replace(/__/g, ' ').replace(/_/g, ' '),
+      isMcp: true,
+    }
+  }
+
+  const parts = name
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .replace(/_/g, ' ')
+    .toLowerCase()
+    .split(/\s+/)
+    .filter(Boolean)
+
+  return {
+    parts,
+    full: parts.join(' '),
+    isMcp: false,
+  }
+}
+
+function compileTermPatterns(terms: readonly string[]): Map<string, RegExp> {
+  const patterns = new Map<string, RegExp>()
+  for (const term of terms) {
+    if (!patterns.has(term)) {
+      patterns.set(term, new RegExp(`\\b${escapeRegExp(term)}\\b`))
+    }
+  }
+  return patterns
+}
+
+function getTermPattern(
+  patterns: ReadonlyMap<string, RegExp>,
+  term: string,
+): RegExp {
+  return patterns.get(term) ?? new RegExp(`\\b${escapeRegExp(term)}\\b`)
+}
+
+function splitQueryTerms(queryLower: string): {
+  readonly requiredTerms: readonly string[]
+  readonly optionalTerms: readonly string[]
+  readonly queryTerms: readonly string[]
+} {
+  const queryTerms = expandedToolSearchTerms(queryLower)
+  const requiredTerms: string[] = []
+  const optionalTerms: string[] = []
+  for (const term of queryTerms) {
+    if (term.startsWith('+') && term.length > 1) {
+      requiredTerms.push(term.slice(1))
+    } else {
+      optionalTerms.push(term)
+    }
+  }
+  return { requiredTerms, optionalTerms, queryTerms }
+}
+
+function requiredTermMatches({
+  parsed,
+  descNormalized,
+  hintNormalized,
+  expandedTerms,
+  termPatterns,
+  term,
+}: {
+  readonly parsed: ParsedToolName
+  readonly descNormalized: string
+  readonly hintNormalized: string
+  readonly expandedTerms: ReadonlySet<string>
+  readonly termPatterns: ReadonlyMap<string, RegExp>
+  readonly term: string
+}): boolean {
+  const pattern = getTermPattern(termPatterns, term)
+  const canUsePromptBody = !expandedTerms.has(term)
+  return (
+    parsed.parts.includes(term) ||
+    parsed.parts.some(part => part.includes(term)) ||
+    (canUsePromptBody && pattern.test(descNormalized)) ||
+    (hintNormalized.length > 0 && pattern.test(hintNormalized))
+  )
+}
+
+async function filterRequiredTermMatches(
+  deferredTools: Tools,
+  tools: Tools,
+  requiredTerms: readonly string[],
+  expandedTerms: ReadonlySet<string>,
+  termPatterns: ReadonlyMap<string, RegExp>,
+): Promise<Tools> {
+  if (requiredTerms.length === 0) return deferredTools
+  const matches = await Promise.all(
+    deferredTools.map(async tool => {
+      const parsed = parseToolName(tool.name)
+      const description = await getToolDescriptionMemoized(tool.name, tools)
+      const descNormalized = description.toLowerCase()
+      const hintNormalized = tool.searchHint?.toLowerCase() ?? ''
+      const matchesAll = requiredTerms.every(term =>
+        requiredTermMatches({
+          parsed,
+          descNormalized,
+          hintNormalized,
+          expandedTerms,
+          termPatterns,
+          term,
+        }),
+      )
+      return matchesAll ? tool : null
+    }),
+  )
+  return matches.filter((tool): tool is Tool => tool !== null)
+}
+
+async function scoreTool(
+  tool: Tool,
+  tools: Tools,
+  allScoringTerms: readonly string[],
+  expandedTerms: ReadonlySet<string>,
+  termPatterns: ReadonlyMap<string, RegExp>,
+): Promise<ScoredTool> {
+  const parsed = parseToolName(tool.name)
+  const description = await getToolDescriptionMemoized(tool.name, tools)
+  const descNormalized = description.toLowerCase()
+  const hintNormalized = tool.searchHint?.toLowerCase() ?? ''
+  let score = 0
+
+  for (const term of allScoringTerms) {
+    const pattern = getTermPattern(termPatterns, term)
+    if (parsed.parts.includes(term)) {
+      score += parsed.isMcp ? 12 : 10
+    } else if (parsed.parts.some(part => part.includes(term))) {
+      score += parsed.isMcp ? 6 : 5
+    }
+    if (parsed.full.includes(term) && score === 0) {
+      score += 3
+    }
+    if (hintNormalized.length > 0 && pattern.test(hintNormalized)) {
+      score += 4
+    }
+    if (!expandedTerms.has(term) && pattern.test(descNormalized)) {
+      score += 2
+    }
+  }
+
+  return { name: tool.name, score }
+}
+
+export async function searchToolsWithKeywords(
+  query: string,
+  deferredTools: Tools,
+  tools: Tools,
+  maxResults: number,
+): Promise<string[]> {
+  const queryLower = query.toLowerCase().trim()
+  const exactMatch =
+    deferredTools.find(tool => tool.name.toLowerCase() === queryLower) ??
+    findToolByName(tools, queryLower)
+  if (exactMatch) {
+    return [exactMatch.name]
+  }
+
+  if (queryLower.startsWith('mcp__') && queryLower.length > 5) {
+    const prefixMatches = deferredTools
+      .filter(tool => tool.name.toLowerCase().startsWith(queryLower))
+      .slice(0, maxResults)
+      .map(tool => tool.name)
+    if (prefixMatches.length > 0) {
+      return prefixMatches
+    }
+  }
+
+  const { requiredTerms, optionalTerms, queryTerms } = splitQueryTerms(queryLower)
+  const allScoringTerms =
+    requiredTerms.length > 0 ? [...requiredTerms, ...optionalTerms] : queryTerms
+  const expandedTerms = expandedIntentTermSet(queryLower)
+  const termPatterns = compileTermPatterns(allScoringTerms)
+  const candidateTools = await filterRequiredTermMatches(
+    deferredTools,
+    tools,
+    requiredTerms,
+    expandedTerms,
+    termPatterns,
+  )
+  const scored = await Promise.all(
+    candidateTools.map(tool =>
+      scoreTool(tool, tools, allScoringTerms, expandedTerms, termPatterns),
+    ),
+  )
+
+  return scored
+    .filter(item => item.score > 0)
+    .sort((left, right) => right.score - left.score)
+    .slice(0, maxResults)
+    .map(item => item.name)
+}

package/tui/src/tools/ToolSearchTool/prompt.ts

@@ -3,6 +3,7 @@ import { isReplBridgeActive } from '../../bootstrap/state.js'
 import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js'
 import type { Tool } from '../../Tool.js'
 import { AGENT_TOOL_NAME } from '../AgentTool/constants.js'
+import { formatDeferredToolSearchLine } from './supportIntentHints.js'
 
 // Dead code elimination: Brief tool name only needed when KAIROS or KAIROS_BRIEF is on
 /* eslint-disable @typescript-eslint/no-require-imports */
@@ -48,7 +49,13 @@ Result format: each matched tool appears as one <function>{"description": "...",
 Query forms:
 - "select:Read,Edit,Grep" — fetch these exact tools by name
 - "notebook jupyter" — keyword search, up to max_results best matches
-- "+slack send" — require "slack" in the name, rank by remaining terms`
+- "+slack send" — require "slack" in the name, rank by remaining terms
+
+Support-tool query examples:
+- "source verification web search" — fetch WebSearch/WebFetch for current evidence and URL source checks
+- "MCP resources" — fetch ListMcpResourcesTool/ReadMcpResourceTool for trusted MCP resource boundaries
+- "Agent progress cancel" — fetch Agent or task tools for delegated research with visible progress/cancel state
+- "workspace write permission" or "shell permission" — fetch workspace write/shell tools when a visible permission or blocked boundary is required`
 
 /**
  * Check if a tool should be deferred (requires ToolSearch to load).
@@ -109,11 +116,10 @@ export function isDeferredTool(tool: Tool): boolean {
 
 /**
  * Format one deferred-tool line for the <available-deferred-tools> user
- * message. Search hints (tool.searchHint) are not rendered — the
- * hints A/B (exp_xenhnnmn0smrx4, stopped Mar 21) showed no benefit.
+ * message. Search hints stay text-only so the block cannot inject markup.
  */
 export function formatDeferredToolLine(tool: Tool): string {
-  return tool.name
+  return formatDeferredToolSearchLine(tool)
 }
 
 export function getPrompt(): string {

package/tui/src/tools/ToolSearchTool/resultMapping.ts

@@ -0,0 +1,30 @@
+import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'
+import type { Output } from './schemas.js'
+
+export function buildSearchResult(
+  matches: string[],
+  query: string,
+  totalDeferredTools: number,
+  pendingMcpServers?: string[],
+): { data: Output } {
+  return {
+    data: {
+      matches,
+      query,
+      total_deferred_tools: totalDeferredTools,
+      ...(pendingMcpServers && pendingMcpServers.length > 0
+        ? { pending_mcp_servers: pendingMcpServers }
+        : {}),
+    },
+  }
+}
+
+export function makeToolReferenceContent(
+  matches: readonly string[],
+): ToolResultBlockParam['content'] {
+  const content = matches.map(name => ({
+    type: 'tool_reference',
+    tool_name: name,
+  }))
+  return JSON.parse(JSON.stringify(content))
+}

package/tui/src/tools/ToolSearchTool/schemas.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod/v4'
+import { lazySchema } from '../../utils/lazySchema.js'
+
+export const inputSchema = lazySchema(() =>
+  z.object({
+    query: z
+      .string()
+      .describe(
+        'Query to find deferred tools. Use "select:<tool_name>" for direct selection, or keywords to search.',
+      ),
+    max_results: z
+      .number()
+      .optional()
+      .default(5)
+      .describe('Maximum number of results to return (default: 5)'),
+  }),
+)
+export type InputSchema = ReturnType<typeof inputSchema>
+
+export const outputSchema = lazySchema(() =>
+  z.object({
+    matches: z.array(z.string()),
+    query: z.string(),
+    total_deferred_tools: z.number(),
+    pending_mcp_servers: z.array(z.string()).optional(),
+  }),
+)
+export type OutputSchema = ReturnType<typeof outputSchema>
+
+export type Output = z.infer<OutputSchema>

package/tui/src/tools/ToolSearchTool/searchPool.ts

@@ -0,0 +1,47 @@
+import type { ToolPermissionContext, Tools } from '../../Tool.js'
+import { isDeferredTool } from './prompt.js'
+import { selectRecoveredSupportToolNamesForQuery } from './supportIntentHints.js'
+
+const DEFAULT_DISCOVERABLE_SUPPORT_TOOLS = new Set(['WebSearch', 'WebFetch'])
+
+function selectedSupportToolNames(query: string): ReadonlySet<string> {
+  const names = new Set(DEFAULT_DISCOVERABLE_SUPPORT_TOOLS)
+  for (const toolName of selectRecoveredSupportToolNamesForQuery(query)) {
+    names.add(toolName)
+  }
+
+  const selectMatch = query.match(/^select:(.+)$/iu)
+  if (selectMatch) {
+    for (const toolName of (selectMatch[1] ?? '').split(',')) {
+      const trimmed = toolName.trim()
+      if (trimmed.length > 0) names.add(trimmed)
+    }
+  }
+  return names
+}
+
+export async function getToolSearchPool(
+  tools: Tools,
+  getAppState: () => { toolPermissionContext?: ToolPermissionContext },
+  query = '',
+): Promise<Tools> {
+  const byName = new Map(tools.map(tool => [tool.name, tool]))
+  const { filterToolsByDenyRules, getAllBaseTools } = await import(
+    '../../tools.js'
+  )
+  const appState = getAppState()
+  const registeredDeferredTools = getAllBaseTools().filter(isDeferredTool)
+  const policyFilteredTools = appState.toolPermissionContext
+    ? filterToolsByDenyRules(
+        registeredDeferredTools,
+        appState.toolPermissionContext,
+      )
+    : registeredDeferredTools
+  const supportToolNames = selectedSupportToolNames(query)
+
+  for (const tool of policyFilteredTools) {
+    if (!byName.has(tool.name) && !supportToolNames.has(tool.name)) continue
+    if (!byName.has(tool.name)) byName.set(tool.name, tool)
+  }
+  return [...byName.values()]
+}