@xelauvas/xela-cli 0.1.0

package/src/tools/WebFetchTool/prompt.ts

@@ -0,0 +1,46 @@
+export const WEB_FETCH_TOOL_NAME = 'WebFetch'
+
+export const DESCRIPTION = `
+- Fetches content from a specified URL and processes it using an AI model
+- Takes a URL and a prompt as input
+- Fetches the URL content, converts HTML to markdown
+- Processes the content with the prompt using a small, fast model
+- Returns the model's response about the content
+- Use this tool when you need to retrieve and analyze web content
+
+Usage notes:
+  - IMPORTANT: If an MCP-provided web fetch tool is available, prefer using that tool instead of this one, as it may have fewer restrictions.
+  - The URL must be a fully-formed valid URL
+  - HTTP URLs will be automatically upgraded to HTTPS
+  - The prompt should describe what information you want to extract from the page
+  - This tool is read-only and does not modify any files
+  - Results may be summarized if the content is very large
+  - Includes a self-cleaning 15-minute cache for faster responses when repeatedly accessing the same URL
+  - When a URL redirects to a different host, the tool will inform you and provide the redirect URL in a special format. You should then make a new WebFetch request with the redirect URL to fetch the content.
+  - For GitHub URLs, prefer using the gh CLI via Bash instead (e.g., gh pr view, gh issue view, gh api).
+`
+
+export function makeSecondaryModelPrompt(
+  markdownContent: string,
+  prompt: string,
+  isPreapprovedDomain: boolean,
+): string {
+  const guidelines = isPreapprovedDomain
+    ? `Provide a concise response based on the content above. Include relevant details, code examples, and documentation excerpts as needed.`
+    : `Provide a concise response based only on the content above. In your response:
+ - Enforce a strict 125-character maximum for quotes from any source document. Open Source Software is ok as long as we respect the license.
+ - Use quotation marks for exact language from articles; any language outside of the quotation should never be word-for-word the same.
+ - You are not a lawyer and never comment on the legality of your own prompts and responses.
+ - Never produce or reproduce exact song lyrics.`
+
+  return `
+Web page content:
+---
+${markdownContent}
+---
+
+${prompt}
+
+${guidelines}
+`
+}

package/src/tools/WebFetchTool/utils.ts

@@ -0,0 +1,530 @@
+import axios, { type AxiosResponse } from 'axios'
+import { LRUCache } from 'lru-cache'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../../services/analytics/index.js'
+import { queryHaiku } from '../../services/api/claude.js'
+import { AbortError } from '../../utils/errors.js'
+import { getWebFetchUserAgent } from '../../utils/http.js'
+import { logError } from '../../utils/log.js'
+import {
+  isBinaryContentType,
+  persistBinaryContent,
+} from '../../utils/mcpOutputStorage.js'
+import { getSettings_DEPRECATED } from '../../utils/settings/settings.js'
+import { asSystemPrompt } from '../../utils/systemPromptType.js'
+import { isPreapprovedHost } from './preapproved.js'
+import { makeSecondaryModelPrompt } from './prompt.js'
+
+// Custom error classes for domain blocking
+class DomainBlockedError extends Error {
+  constructor(domain: string) {
+    super(`Claude Code is unable to fetch from ${domain}`)
+    this.name = 'DomainBlockedError'
+  }
+}
+
+class DomainCheckFailedError extends Error {
+  constructor(domain: string) {
+    super(
+      `Unable to verify if domain ${domain} is safe to fetch. This may be due to network restrictions or enterprise security policies blocking claude.ai.`,
+    )
+    this.name = 'DomainCheckFailedError'
+  }
+}
+
+class EgressBlockedError extends Error {
+  constructor(public readonly domain: string) {
+    super(
+      JSON.stringify({
+        error_type: 'EGRESS_BLOCKED',
+        domain,
+        message: `Access to ${domain} is blocked by the network egress proxy.`,
+      }),
+    )
+    this.name = 'EgressBlockedError'
+  }
+}
+
+// Cache for storing fetched URL content
+type CacheEntry = {
+  bytes: number
+  code: number
+  codeText: string
+  content: string
+  contentType: string
+  persistedPath?: string
+  persistedSize?: number
+}
+
+// Cache with 15-minute TTL and 50MB size limit
+// LRUCache handles automatic expiration and eviction
+const CACHE_TTL_MS = 15 * 60 * 1000 // 15 minutes
+const MAX_CACHE_SIZE_BYTES = 50 * 1024 * 1024 // 50MB
+
+const URL_CACHE = new LRUCache<string, CacheEntry>({
+  maxSize: MAX_CACHE_SIZE_BYTES,
+  ttl: CACHE_TTL_MS,
+})
+
+// Separate cache for preflight domain checks. URL_CACHE is URL-keyed, so
+// fetching two paths on the same domain triggers two identical preflight
+// HTTP round-trips to api.anthropic.com. This hostname-keyed cache avoids
+// that. Only 'allowed' is cached — blocked/failed re-check on next attempt.
+const DOMAIN_CHECK_CACHE = new LRUCache<string, true>({
+  max: 128,
+  ttl: 5 * 60 * 1000, // 5 minutes — shorter than URL_CACHE TTL
+})
+
+export function clearWebFetchCache(): void {
+  URL_CACHE.clear()
+  DOMAIN_CHECK_CACHE.clear()
+}
+
+// Lazy singleton — defers the turndown → @mixmark-io/domino import (~1.4MB
+// retained heap) until the first HTML fetch, and reuses one instance across
+// calls (construction builds 15 rule objects; .turndown() is stateless).
+// @types/turndown ships only `export =` (no .d.mts), so TS types the import
+// as the class itself while Bun wraps CJS in { default } — hence the cast.
+type TurndownCtor = typeof import('turndown')
+let turndownServicePromise: Promise<InstanceType<TurndownCtor>> | undefined
+function getTurndownService(): Promise<InstanceType<TurndownCtor>> {
+  return (turndownServicePromise ??= import('turndown').then(m => {
+    const Turndown = (m as unknown as { default: TurndownCtor }).default
+    return new Turndown()
+  }))
+}
+
+// PSR requested limiting the length of URLs to 250 to lower the potential
+// for a data exfiltration. However, this is too restrictive for some customers'
+// legitimate use cases, such as JWT-signed URLs (e.g., cloud service signed URLs)
+// that can be much longer. We already require user approval for each domain,
+// which provides a primary security boundary. In addition, Claude Code has
+// other data exfil channels, and this one does not seem relatively high risk,
+// so I'm removing that length restriction. -ab
+const MAX_URL_LENGTH = 2000
+
+// Per PSR:
+// "Implement resource consumption controls because setting limits on CPU,
+// memory, and network usage for the Web Fetch tool can prevent a single
+// request or user from overwhelming the system."
+const MAX_HTTP_CONTENT_LENGTH = 10 * 1024 * 1024
+
+// Timeout for the main HTTP fetch request (60 seconds).
+// Prevents hanging indefinitely on slow/unresponsive servers.
+const FETCH_TIMEOUT_MS = 60_000
+
+// Timeout for the domain blocklist preflight check (10 seconds).
+const DOMAIN_CHECK_TIMEOUT_MS = 10_000
+
+// Cap same-host redirect hops. Without this a malicious server can return
+// a redirect loop (/a → /b → /a …) and the per-request FETCH_TIMEOUT_MS
+// resets on every hop, hanging the tool until user interrupt. 10 matches
+// common client defaults (axios=5, follow-redirects=21, Chrome=20).
+const MAX_REDIRECTS = 10
+
+// Truncate to not spend too many tokens
+export const MAX_MARKDOWN_LENGTH = 100_000
+
+export function isPreapprovedUrl(url: string): boolean {
+  try {
+    const parsedUrl = new URL(url)
+    return isPreapprovedHost(parsedUrl.hostname, parsedUrl.pathname)
+  } catch {
+    return false
+  }
+}
+
+export function validateURL(url: string): boolean {
+  if (url.length > MAX_URL_LENGTH) {
+    return false
+  }
+
+  let parsed
+  try {
+    parsed = new URL(url)
+  } catch {
+    return false
+  }
+
+  // We don't need to check protocol here, as we'll upgrade http to https when making the request
+
+  // As long as we aren't supporting aiming to cookies or internal domains,
+  // we should block URLs with usernames/passwords too, even though these
+  // seem exceedingly unlikely.
+  if (parsed.username || parsed.password) {
+    return false
+  }
+
+  // Initial filter that this isn't a privileged, company-internal URL
+  // by checking that the hostname is publicly resolvable
+  const hostname = parsed.hostname
+  const parts = hostname.split('.')
+  if (parts.length < 2) {
+    return false
+  }
+
+  return true
+}
+
+type DomainCheckResult =
+  | { status: 'allowed' }
+  | { status: 'blocked' }
+  | { status: 'check_failed'; error: Error }
+
+export async function checkDomainBlocklist(
+  domain: string,
+): Promise<DomainCheckResult> {
+  if (DOMAIN_CHECK_CACHE.has(domain)) {
+    return { status: 'allowed' }
+  }
+  try {
+    const response = await axios.get(
+      `https://api.anthropic.com/api/web/domain_info?domain=${encodeURIComponent(domain)}`,
+      { timeout: DOMAIN_CHECK_TIMEOUT_MS },
+    )
+    if (response.status === 200) {
+      if (response.data.can_fetch === true) {
+        DOMAIN_CHECK_CACHE.set(domain, true)
+        return { status: 'allowed' }
+      }
+      return { status: 'blocked' }
+    }
+    // Non-200 status but didn't throw
+    return {
+      status: 'check_failed',
+      error: new Error(`Domain check returned status ${response.status}`),
+    }
+  } catch (e) {
+    logError(e)
+    return { status: 'check_failed', error: e as Error }
+  }
+}
+
+/**
+ * Check if a redirect is safe to follow
+ * Allows redirects that:
+ * - Add or remove "www." in the hostname
+ * - Keep the origin the same but change path/query params
+ * - Or both of the above
+ */
+export function isPermittedRedirect(
+  originalUrl: string,
+  redirectUrl: string,
+): boolean {
+  try {
+    const parsedOriginal = new URL(originalUrl)
+    const parsedRedirect = new URL(redirectUrl)
+
+    if (parsedRedirect.protocol !== parsedOriginal.protocol) {
+      return false
+    }
+
+    if (parsedRedirect.port !== parsedOriginal.port) {
+      return false
+    }
+
+    if (parsedRedirect.username || parsedRedirect.password) {
+      return false
+    }
+
+    // Now check hostname conditions
+    // 1. Adding www. is allowed: example.com -> www.example.com
+    // 2. Removing www. is allowed: www.example.com -> example.com
+    // 3. Same host (with or without www.) is allowed: paths can change
+    const stripWww = (hostname: string) => hostname.replace(/^www\./, '')
+    const originalHostWithoutWww = stripWww(parsedOriginal.hostname)
+    const redirectHostWithoutWww = stripWww(parsedRedirect.hostname)
+    return originalHostWithoutWww === redirectHostWithoutWww
+  } catch (_error) {
+    return false
+  }
+}
+
+/**
+ * Helper function to handle fetching URLs with custom redirect handling
+ * Recursively follows redirects if they pass the redirectChecker function
+ *
+ * Per PSR:
+ * "Do not automatically follow redirects because following redirects could
+ * allow for an attacker to exploit an open redirect vulnerability in a
+ * trusted domain to force a user to make a request to a malicious domain
+ * unknowingly"
+ */
+type RedirectInfo = {
+  type: 'redirect'
+  originalUrl: string
+  redirectUrl: string
+  statusCode: number
+}
+
+export async function getWithPermittedRedirects(
+  url: string,
+  signal: AbortSignal,
+  redirectChecker: (originalUrl: string, redirectUrl: string) => boolean,
+  depth = 0,
+): Promise<AxiosResponse<ArrayBuffer> | RedirectInfo> {
+  if (depth > MAX_REDIRECTS) {
+    throw new Error(`Too many redirects (exceeded ${MAX_REDIRECTS})`)
+  }
+  try {
+    return await axios.get(url, {
+      signal,
+      timeout: FETCH_TIMEOUT_MS,
+      maxRedirects: 0,
+      responseType: 'arraybuffer',
+      maxContentLength: MAX_HTTP_CONTENT_LENGTH,
+      headers: {
+        Accept: 'text/markdown, text/html, */*',
+        'User-Agent': getWebFetchUserAgent(),
+      },
+    })
+  } catch (error) {
+    if (
+      axios.isAxiosError(error) &&
+      error.response &&
+      [301, 302, 307, 308].includes(error.response.status)
+    ) {
+      const redirectLocation = error.response.headers.location
+      if (!redirectLocation) {
+        throw new Error('Redirect missing Location header')
+      }
+
+      // Resolve relative URLs against the original URL
+      const redirectUrl = new URL(redirectLocation, url).toString()
+
+      if (redirectChecker(url, redirectUrl)) {
+        // Recursively follow the permitted redirect
+        return getWithPermittedRedirects(
+          redirectUrl,
+          signal,
+          redirectChecker,
+          depth + 1,
+        )
+      } else {
+        // Return redirect information to the caller
+        return {
+          type: 'redirect',
+          originalUrl: url,
+          redirectUrl,
+          statusCode: error.response.status,
+        }
+      }
+    }
+
+    // Detect egress proxy blocks: the proxy returns 403 with
+    // X-Proxy-Error: blocked-by-allowlist when egress is restricted
+    if (
+      axios.isAxiosError(error) &&
+      error.response?.status === 403 &&
+      error.response.headers['x-proxy-error'] === 'blocked-by-allowlist'
+    ) {
+      const hostname = new URL(url).hostname
+      throw new EgressBlockedError(hostname)
+    }
+
+    throw error
+  }
+}
+
+function isRedirectInfo(
+  response: AxiosResponse<ArrayBuffer> | RedirectInfo,
+): response is RedirectInfo {
+  return 'type' in response && response.type === 'redirect'
+}
+
+export type FetchedContent = {
+  content: string
+  bytes: number
+  code: number
+  codeText: string
+  contentType: string
+  persistedPath?: string
+  persistedSize?: number
+}
+
+export async function getURLMarkdownContent(
+  url: string,
+  abortController: AbortController,
+): Promise<FetchedContent | RedirectInfo> {
+  if (!validateURL(url)) {
+    throw new Error('Invalid URL')
+  }
+
+  // Check cache (LRUCache handles TTL automatically)
+  const cachedEntry = URL_CACHE.get(url)
+  if (cachedEntry) {
+    return {
+      bytes: cachedEntry.bytes,
+      code: cachedEntry.code,
+      codeText: cachedEntry.codeText,
+      content: cachedEntry.content,
+      contentType: cachedEntry.contentType,
+      persistedPath: cachedEntry.persistedPath,
+      persistedSize: cachedEntry.persistedSize,
+    }
+  }
+
+  let parsedUrl: URL
+  let upgradedUrl = url
+
+  try {
+    parsedUrl = new URL(url)
+
+    // Upgrade http to https if needed
+    if (parsedUrl.protocol === 'http:') {
+      parsedUrl.protocol = 'https:'
+      upgradedUrl = parsedUrl.toString()
+    }
+
+    const hostname = parsedUrl.hostname
+
+    // Check if the user has opted to skip the blocklist check
+    // This is for enterprise customers with restrictive security policies
+    // that prevent outbound connections to claude.ai
+    const settings = getSettings_DEPRECATED()
+    if (!settings.skipWebFetchPreflight) {
+      const checkResult = await checkDomainBlocklist(hostname)
+      switch (checkResult.status) {
+        case 'allowed':
+          // Continue with the fetch
+          break
+        case 'blocked':
+          throw new DomainBlockedError(hostname)
+        case 'check_failed':
+          throw new DomainCheckFailedError(hostname)
+      }
+    }
+
+    if (process.env.USER_TYPE === 'ant') {
+      logEvent('tengu_web_fetch_host', {
+        hostname:
+          hostname as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      })
+    }
+  } catch (e) {
+    if (
+      e instanceof DomainBlockedError ||
+      e instanceof DomainCheckFailedError
+    ) {
+      // Expected user-facing failures - re-throw without logging as internal error
+      throw e
+    }
+    logError(e)
+  }
+
+  const response = await getWithPermittedRedirects(
+    upgradedUrl,
+    abortController.signal,
+    isPermittedRedirect,
+  )
+
+  // Check if we got a redirect response
+  if (isRedirectInfo(response)) {
+    return response
+  }
+
+  const rawBuffer = Buffer.from(response.data)
+  // Release the axios-held ArrayBuffer copy; rawBuffer owns the bytes now.
+  // This lets GC reclaim up to MAX_HTTP_CONTENT_LENGTH (10MB) before Turndown
+  // builds its DOM tree (which can be 3-5x the HTML size).
+  ;(response as { data: unknown }).data = null
+  const contentType = response.headers['content-type'] ?? ''
+
+  // Binary content: save raw bytes to disk with a proper extension so Claude
+  // can inspect the file later. We still fall through to the utf-8 decode +
+  // Haiku path below — for PDFs in particular the decoded string has enough
+  // ASCII structure (/Title, text streams) that Haiku can summarize it, and
+  // the saved file is a supplement rather than a replacement.
+  let persistedPath: string | undefined
+  let persistedSize: number | undefined
+  if (isBinaryContentType(contentType)) {
+    const persistId = `webfetch-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+    const result = await persistBinaryContent(rawBuffer, contentType, persistId)
+    if (!('error' in result)) {
+      persistedPath = result.filepath
+      persistedSize = result.size
+    }
+  }
+
+  const bytes = rawBuffer.length
+  const htmlContent = rawBuffer.toString('utf-8')
+
+  let markdownContent: string
+  let contentBytes: number
+  if (contentType.includes('text/html')) {
+    markdownContent = (await getTurndownService()).turndown(htmlContent)
+    contentBytes = Buffer.byteLength(markdownContent)
+  } else {
+    // It's not HTML - just use it raw. The decoded string's UTF-8 byte
+    // length equals rawBuffer.length (modulo U+FFFD replacement on invalid
+    // bytes — negligible for cache eviction accounting), so skip the O(n)
+    // Buffer.byteLength scan.
+    markdownContent = htmlContent
+    contentBytes = bytes
+  }
+
+  // Store the fetched content in cache. Note that it's stored under
+  // the original URL, not the upgraded or redirected URL.
+  const entry: CacheEntry = {
+    bytes,
+    code: response.status,
+    codeText: response.statusText,
+    content: markdownContent,
+    contentType,
+    persistedPath,
+    persistedSize,
+  }
+  // lru-cache requires positive integers; clamp to 1 for empty responses.
+  URL_CACHE.set(url, entry, { size: Math.max(1, contentBytes) })
+  return entry
+}
+
+export async function applyPromptToMarkdown(
+  prompt: string,
+  markdownContent: string,
+  signal: AbortSignal,
+  isNonInteractiveSession: boolean,
+  isPreapprovedDomain: boolean,
+): Promise<string> {
+  // Truncate content to avoid "Prompt is too long" errors from the secondary model
+  const truncatedContent =
+    markdownContent.length > MAX_MARKDOWN_LENGTH
+      ? markdownContent.slice(0, MAX_MARKDOWN_LENGTH) +
+        '\n\n[Content truncated due to length...]'
+      : markdownContent
+
+  const modelPrompt = makeSecondaryModelPrompt(
+    truncatedContent,
+    prompt,
+    isPreapprovedDomain,
+  )
+  const assistantMessage = await queryHaiku({
+    systemPrompt: asSystemPrompt([]),
+    userPrompt: modelPrompt,
+    signal,
+    options: {
+      querySource: 'web_fetch_apply',
+      agents: [],
+      isNonInteractiveSession,
+      hasAppendSystemPrompt: false,
+      mcpTools: [],
+    },
+  })
+
+  // We need to bubble this up, so that the tool call throws, causing us to return
+  // an is_error tool_use block to the server, and render a red dot in the UI.
+  if (signal.aborted) {
+    throw new AbortError()
+  }
+
+  const { content } = assistantMessage.message
+  if (content.length > 0) {
+    const contentBlock = content[0]
+    if ('text' in contentBlock!) {
+      return contentBlock.text
+    }
+  }
+  return 'No response from model'
+}

package/src/tools/WebSearchTool/UI.tsx

@@ -0,0 +1,101 @@
+import React from 'react';
+import { MessageResponse } from '../../components/MessageResponse.js';
+import { TOOL_SUMMARY_MAX_LENGTH } from '../../constants/toolLimits.js';
+import { Box, Text } from '../../ink.js';
+import type { ProgressMessage } from '../../types/message.js';
+import { truncate } from '../../utils/format.js';
+import type { Output, SearchResult, WebSearchProgress } from './WebSearchTool.js';
+function getSearchSummary(results: (SearchResult | string | null | undefined)[]): {
+  searchCount: number;
+  totalResultCount: number;
+} {
+  let searchCount = 0;
+  let totalResultCount = 0;
+  for (const result of results) {
+    if (result != null && typeof result !== 'string') {
+      searchCount++;
+      totalResultCount += result.content?.length ?? 0;
+    }
+  }
+  return {
+    searchCount,
+    totalResultCount
+  };
+}
+export function renderToolUseMessage({
+  query,
+  allowed_domains,
+  blocked_domains
+}: Partial<{
+  query: string;
+  allowed_domains?: string[];
+  blocked_domains?: string[];
+}>, {
+  verbose
+}: {
+  verbose: boolean;
+}): React.ReactNode {
+  if (!query) {
+    return null;
+  }
+  let message = '';
+  if (query) {
+    message += `"${query}"`;
+  }
+  if (verbose) {
+    if (allowed_domains && allowed_domains.length > 0) {
+      message += `, only allowing domains: ${allowed_domains.join(', ')}`;
+    }
+    if (blocked_domains && blocked_domains.length > 0) {
+      message += `, blocking domains: ${blocked_domains.join(', ')}`;
+    }
+  }
+  return message;
+}
+export function renderToolUseProgressMessage(progressMessages: ProgressMessage<WebSearchProgress>[]): React.ReactNode {
+  if (progressMessages.length === 0) {
+    return null;
+  }
+  const lastProgress = progressMessages[progressMessages.length - 1];
+  if (!lastProgress?.data) {
+    return null;
+  }
+  const data = lastProgress.data;
+  switch (data.type) {
+    case 'query_update':
+      return <MessageResponse>
+          <Text dimColor>Searching: {data.query}</Text>
+        </MessageResponse>;
+    case 'search_results_received':
+      return <MessageResponse>
+          <Text dimColor>
+            Found {data.resultCount} results for &quot;{data.query}&quot;
+          </Text>
+        </MessageResponse>;
+    default:
+      return null;
+  }
+}
+export function renderToolResultMessage(output: Output): React.ReactNode {
+  const {
+    searchCount
+  } = getSearchSummary(output.results ?? []);
+  const timeDisplay = output.durationSeconds >= 1 ? `${Math.round(output.durationSeconds)}s` : `${Math.round(output.durationSeconds * 1000)}ms`;
+  return <Box justifyContent="space-between" width="100%">
+      <MessageResponse height={1}>
+        <Text>
+          Did {searchCount} search
+          {searchCount !== 1 ? 'es' : ''} in {timeDisplay}
+        </Text>
+      </MessageResponse>
+    </Box>;
+}
+export function getToolUseSummary(input: Partial<{
+  query: string;
+}> | undefined): string | null {
+  if (!input?.query) {
+    return null;
+  }
+  return truncate(input.query, TOOL_SUMMARY_MAX_LENGTH);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","MessageResponse","TOOL_SUMMARY_MAX_LENGTH","Box","Text","ProgressMessage","truncate","Output","SearchResult","WebSearchProgress","getSearchSummary","results","searchCount","totalResultCount","result","content","length","renderToolUseMessage","query","allowed_domains","blocked_domains","Partial","verbose","ReactNode","message","join","renderToolUseProgressMessage","progressMessages","lastProgress","data","type","resultCount","renderToolResultMessage","output","timeDisplay","durationSeconds","Math","round","getToolUseSummary","input"],"sources":["UI.tsx"],"sourcesContent":["import React from 'react'\nimport { MessageResponse } from '../../components/MessageResponse.js'\nimport { TOOL_SUMMARY_MAX_LENGTH } from '../../constants/toolLimits.js'\nimport { Box, Text } from '../../ink.js'\nimport type { ProgressMessage } from '../../types/message.js'\nimport { truncate } from '../../utils/format.js'\nimport type {\n  Output,\n  SearchResult,\n  WebSearchProgress,\n} from './WebSearchTool.js'\n\nfunction getSearchSummary(\n  results: (SearchResult | string | null | undefined)[],\n): {\n  searchCount: number\n  totalResultCount: number\n} {\n  let searchCount = 0\n  let totalResultCount = 0\n\n  for (const result of results) {\n    if (result != null && typeof result !== 'string') {\n      searchCount++\n      totalResultCount += result.content?.length ?? 0\n    }\n  }\n\n  return { searchCount, totalResultCount }\n}\n\nexport function renderToolUseMessage(\n  {\n    query,\n    allowed_domains,\n    blocked_domains,\n  }: Partial<{\n    query: string\n    allowed_domains?: string[]\n    blocked_domains?: string[]\n  }>,\n  { verbose }: { verbose: boolean },\n): React.ReactNode {\n  if (!query) {\n    return null\n  }\n\n  let message = ''\n\n  if (query) {\n    message += `\"${query}\"`\n  }\n\n  if (verbose) {\n    if (allowed_domains && allowed_domains.length > 0) {\n      message += `, only allowing domains: ${allowed_domains.join(', ')}`\n    }\n\n    if (blocked_domains && blocked_domains.length > 0) {\n      message += `, blocking domains: ${blocked_domains.join(', ')}`\n    }\n  }\n\n  return message\n}\n\nexport function renderToolUseProgressMessage(\n  progressMessages: ProgressMessage<WebSearchProgress>[],\n): React.ReactNode {\n  if (progressMessages.length === 0) {\n    return null\n  }\n\n  const lastProgress = progressMessages[progressMessages.length - 1]\n  if (!lastProgress?.data) {\n    return null\n  }\n\n  const data = lastProgress.data\n\n  switch (data.type) {\n    case 'query_update':\n      return (\n        <MessageResponse>\n          <Text dimColor>Searching: {data.query}</Text>\n        </MessageResponse>\n      )\n    case 'search_results_received':\n      return (\n        <MessageResponse>\n          <Text dimColor>\n            Found {data.resultCount} results for &quot;{data.query}&quot;\n          </Text>\n        </MessageResponse>\n      )\n    default:\n      return null\n  }\n}\n\nexport function renderToolResultMessage(output: Output): React.ReactNode {\n  const { searchCount } = getSearchSummary(output.results ?? [])\n  const timeDisplay =\n    output.durationSeconds >= 1\n      ? `${Math.round(output.durationSeconds)}s`\n      : `${Math.round(output.durationSeconds * 1000)}ms`\n\n  return (\n    <Box justifyContent=\"space-between\" width=\"100%\">\n      <MessageResponse height={1}>\n        <Text>\n          Did {searchCount} search\n          {searchCount !== 1 ? 'es' : ''} in {timeDisplay}\n        </Text>\n      </MessageResponse>\n    </Box>\n  )\n}\n\nexport function getToolUseSummary(\n  input: Partial<{ query: string }> | undefined,\n): string | null {\n  if (!input?.query) {\n    return null\n  }\n  return truncate(input.query, TOOL_SUMMARY_MAX_LENGTH)\n}\n"],"mappings":"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","ignoreList":[]}