ummaya 0.2.4 → 0.2.6

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

@@ -0,0 +1,140 @@
+import type { Tool } from '../../Tool.js'
+
+const SOURCE_SUPPORT_INTENT_PATTERN =
+  /출처|근거|인용|참고\s*문헌|레퍼런스|출전|증빙|증거|자료\s*(?:출처|근거|조사|검색)|최신|현재\s*(?:정보|자료)|웹\s*검색|source|citation|evidence|provenance|reference|bibliography|current\s+(?:information|source|research)|latest|web\s*search|search\s+the\s+web|https?:\/\//iu
+
+const MCP_SUPPORT_INTENT_PATTERN =
+  /(?:\bmcp\b|mcp__|(?=.*(?:리소스|자원|resources?))(?=.*(?:신뢰\s*경계|신뢰|경계|trust|boundary|connected\s+servers?|서버\s*(?:리소스|자원)|servers?\s+resources?)))/iu
+
+const AGENT_SUPPORT_INTENT_PATTERN =
+  /에이전트|sub-?agent|agent|별도\s*작업|하위\s*작업|작업자|작업\s*도구|진행\s*상황|취소\s*가능|cancel(?:lable)?\s+task|delegat(?:e|ion)|background\s+task/iu
+
+const KOREAN_QUERY_EXPANSIONS: readonly {
+  readonly pattern: RegExp
+  readonly terms: readonly string[]
+}[] = [
+  {
+    pattern:
+      /(?=.*(?:저장소|작업\s*공간|워크\s*스페이스|로컬|프로젝트|코드\s*베이스|repository|repo|workspace|codebase))(?=.*(?:파일|경로|첫\s*줄|읽|검색|찾|grep|read))/iu,
+    terms: ['+workspace', 'local', 'file', 'read', 'grep', 'search'],
+  },
+  {
+    pattern: SOURCE_SUPPORT_INTENT_PATTERN,
+    terms: [
+      'web',
+      'search',
+      'current',
+      'information',
+      'fetch',
+      'url',
+      'source',
+      'verification',
+    ],
+  },
+  {
+    pattern: MCP_SUPPORT_INTENT_PATTERN,
+    terms: ['mcp', 'resources', 'list', 'connected', 'servers'],
+  },
+  {
+    pattern: AGENT_SUPPORT_INTENT_PATTERN,
+    terms: ['+agent', 'delegate', 'subagent', 'task', 'cancel', 'progress'],
+  },
+  {
+    pattern: /쉘|셸|명령|터미널|git/iu,
+    terms: ['shell', 'bash', 'commands', 'permission', 'blocked'],
+  },
+  {
+    pattern: /쓰기|작성|저장|파일|메모|승인|작업공간/iu,
+    terms: ['create', 'overwrite', 'local', 'text', 'files', 'permission', 'blocked'],
+  },
+]
+
+const SUPPORT_TOOL_NAMES_BY_PATTERN: readonly {
+  readonly pattern: RegExp
+  readonly toolNames: readonly string[]
+}[] = [
+  {
+    pattern:
+      /(?=.*(?:저장소|작업\s*공간|워크\s*스페이스|로컬|프로젝트|코드\s*베이스|repository|repo|workspace|codebase))(?=.*(?:파일|경로|첫\s*줄|읽|검색|찾|grep|read))/iu,
+    toolNames: ['workspace_grep', 'workspace_read'],
+  },
+  {
+    pattern: SOURCE_SUPPORT_INTENT_PATTERN,
+    toolNames: ['WebSearch', 'WebFetch'],
+  },
+  {
+    pattern: MCP_SUPPORT_INTENT_PATTERN,
+    toolNames: ['ListMcpResourcesTool'],
+  },
+  {
+    pattern: AGENT_SUPPORT_INTENT_PATTERN,
+    toolNames: ['Agent'],
+  },
+  {
+    pattern: /쉘|셸|명령|터미널|git/iu,
+    toolNames: ['workspace_bash'],
+  },
+  {
+    pattern: /쓰기|작성|저장|파일|메모|승인|작업공간/iu,
+    toolNames: ['workspace_write'],
+  },
+]
+
+export function expandedToolSearchTerms(queryLower: string): string[] {
+  const terms = queryLower.split(/\s+/).filter(term => term.length > 0)
+  for (const expansion of KOREAN_QUERY_EXPANSIONS) {
+    if (expansion.pattern.test(queryLower)) {
+      terms.push(...expansion.terms)
+    }
+  }
+  return [...new Set(terms)]
+}
+
+export function expandedIntentTermSet(queryLower: string): ReadonlySet<string> {
+  const expandedTerms: string[] = []
+  for (const expansion of KOREAN_QUERY_EXPANSIONS) {
+    if (expansion.pattern.test(queryLower)) {
+      expandedTerms.push(
+        ...expansion.terms.map(term =>
+          term.startsWith('+') ? term.slice(1) : term,
+        ),
+      )
+    }
+  }
+  return new Set(expandedTerms)
+}
+
+export function selectRecoveredSupportToolNamesForQuery(
+  query: string,
+): readonly string[] {
+  const queryLower = query.toLowerCase()
+  const shellIntent = /쉘|셸|명령|터미널|git/iu.test(queryLower)
+  const localWorkspaceFileIntent =
+    /(?:저장소|작업\s*공간|워크\s*스페이스|로컬|프로젝트|코드\s*베이스|repository|repo|workspace|codebase)/iu.test(
+      queryLower,
+    ) &&
+    /(?:파일|경로|첫\s*줄|읽|검색|찾|grep|read)/iu.test(queryLower)
+  if (localWorkspaceFileIntent && !shellIntent) {
+    return ['workspace_grep', 'workspace_read']
+  }
+
+  const toolNames: string[] = []
+  for (const supportClass of SUPPORT_TOOL_NAMES_BY_PATTERN) {
+    if (supportClass.pattern.test(queryLower)) {
+      toolNames.push(...supportClass.toolNames)
+    }
+  }
+  return [...new Set(toolNames)]
+}
+
+function sanitizeSearchHint(searchHint: string): string {
+  return searchHint
+    .replace(/[<>]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+export function formatDeferredToolSearchLine(tool: Tool): string {
+  const searchHint = tool.searchHint ? sanitizeSearchHint(tool.searchHint) : ''
+  return searchHint ? `${tool.name} - ${searchHint}` : tool.name
+}

package/tui/src/tools/TranslateTool/TranslateTool.ts

@@ -58,7 +58,7 @@ type OutputSchema = ReturnType<typeof outputSchema>
 export type Output = z.infer<OutputSchema>
 
 // ---------------------------------------------------------------------------
-// The UMMAYA model identifier (matches services/api/claude.ts)
+// The UMMAYA model identifier (matches services/api/ummaya.ts)
 // ---------------------------------------------------------------------------
 
 const UMMAYA_MODEL = 'LGAI-EXAONE/K-EXAONE-236B-A23B'

package/tui/src/tools/VerifyPrimitive/VerifyPrimitive.ts

@@ -388,7 +388,8 @@ export const VerifyPrimitive = buildTool({
   async checkPermissions(_input) {
     return {
       behavior: 'ask' as const,
-      message: 'Permission delegation required: send identity information to the auth provider. Continue?',
+      message:
+        '권한 위임 필요: 인증 제공자에게 신원 정보를 전달합니다. 계속할까요? / Permission delegation required: send identity information to the auth provider.',
     }
   },
 

package/tui/src/tools/WebFetchTool/WebFetchTool.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod/v4'
 import { buildTool, type ToolDef } from '../../Tool.js'
 import type { PermissionUpdate } from '../../types/permissions.js'
-import { formatFileSize } from '../../utils/format.js'
 import { lazySchema } from '../../utils/lazySchema.js'
 import type { PermissionDecision } from '../../utils/permissions/PermissionResult.js'
 import { getRuleByContentsForTool } from '../../utils/permissions/permissions.js'
+import { callWebFetch } from './call.js'
 import { isPreapprovedHost } from './preapproved.js'
 import { DESCRIPTION, WEB_FETCH_TOOL_NAME } from './prompt.js'
 import {
@@ -14,12 +14,12 @@ import {
   renderToolUseProgressMessage,
 } from './UI.js'
 import {
-  applyPromptToMarkdown,
-  type FetchedContent,
-  getURLMarkdownContent,
-  isPreapprovedUrl,
-  MAX_MARKDOWN_LENGTH,
-} from './utils.js'
+  formatSourceVerifiedToolResult,
+  sourceVerificationSchema,
+} from './sourceVerification.js'
+import type { WebFetchOutput } from './types.js'
+import { validateResolvedPublicWebFetchUrl } from './resolvedAddressSafety.js'
+import { validatePublicWebFetchUrl } from './urlSafety.js'
 
 const inputSchema = lazySchema(() =>
   z.strictObject({
@@ -41,42 +41,31 @@ const outputSchema = lazySchema(() =>
       .number()
       .describe('Time taken to fetch and process the content'),
     url: z.string().describe('The URL that was fetched'),
+    sourceVerification: sourceVerificationSchema.optional(),
   }),
 )
 type OutputSchema = ReturnType<typeof outputSchema>
 
-export type Output = z.infer<OutputSchema>
+export type Output = WebFetchOutput
 
 function webFetchToolInputToPermissionRuleContent(input: {
-  [k: string]: unknown
+  readonly url: string
 }): string {
-  try {
-    const parsedInput = WebFetchTool.inputSchema.safeParse(input)
-    if (!parsedInput.success) {
-      return `input:${input.toString()}`
-    }
-    const { url } = parsedInput.data
-    const hostname = new URL(url).hostname
-    return `domain:${hostname}`
-  } catch {
-    return `input:${input.toString()}`
-  }
+  const validation = validatePublicWebFetchUrl(input.url)
+  return validation.ok ? `domain:${validation.hostname}` : `input:${input.url}`
 }
 
 export const WebFetchTool = buildTool({
   name: WEB_FETCH_TOOL_NAME,
-  searchHint: 'fetch and extract content from a URL',
+  searchHint: 'fetch and extract content from a URL for source verification',
   // 100K chars - tool result persistence threshold
   maxResultSizeChars: 100_000,
   shouldDefer: true,
   async description(input) {
-    const { url } = input as { url: string }
-    try {
-      const hostname = new URL(url).hostname
-      return `UMMAYA wants to fetch content from ${hostname}`
-    } catch {
-      return `UMMAYA wants to fetch content from this URL`
-    }
+    const validation = validatePublicWebFetchUrl(input.url)
+    return validation.ok
+      ? `UMMAYA wants to fetch content from ${validation.hostname}`
+      : `UMMAYA wants to fetch content from this URL`
   },
   userFacingName() {
     return 'Fetch'
@@ -104,20 +93,28 @@ export const WebFetchTool = buildTool({
   async checkPermissions(input, context): Promise<PermissionDecision> {
     const appState = context.getAppState()
     const permissionContext = appState.toolPermissionContext
+    const validation = await validateResolvedPublicWebFetchUrl(input.url)
+
+    if (!validation.ok) {
+      return {
+        behavior: 'deny',
+        message: `${WebFetchTool.name} rejected unsafe URL: ${validation.message}`,
+        decisionReason: { type: 'other', reason: validation.reason },
+      }
+    }
 
     // Check if the hostname is in the preapproved list
-    try {
-      const { url } = input as { url: string }
-      const parsedUrl = new URL(url)
-      if (isPreapprovedHost(parsedUrl.hostname, parsedUrl.pathname)) {
-        return {
-          behavior: 'allow',
-          updatedInput: input,
-          decisionReason: { type: 'other', reason: 'Preapproved host' },
-        }
+    if (
+      isPreapprovedHost(
+        validation.parsedUrl.hostname,
+        validation.parsedUrl.pathname,
+      )
+    ) {
+      return {
+        behavior: 'allow',
+        updatedInput: input,
+        decisionReason: { type: 'other', reason: 'Preapproved host' },
       }
-    } catch {
-      // If URL parsing fails, continue with normal permission checks
     }
 
     // Check for a rule specific to the tool input (matching hostname)
@@ -190,13 +187,12 @@ ${DESCRIPTION}`
   },
   async validateInput(input) {
     const { url } = input
-    try {
-      new URL(url)
-    } catch {
+    const validation = await validateResolvedPublicWebFetchUrl(url)
+    if (!validation.ok) {
       return {
         result: false,
-        message: `Error: Invalid URL "${url}". The URL provided could not be parsed.`,
-        meta: { reason: 'invalid_url' },
+        message: `Error: ${validation.message}`,
+        meta: { reason: validation.reason },
         errorCode: 1,
       }
     }
@@ -205,103 +201,12 @@ ${DESCRIPTION}`
   renderToolUseMessage,
   renderToolUseProgressMessage,
   renderToolResultMessage,
-  async call(
-    { url, prompt },
-    { abortController, options: { isNonInteractiveSession } },
-  ) {
-    const start = Date.now()
-
-    const response = await getURLMarkdownContent(url, abortController)
-
-    // Check if we got a redirect to a different host
-    if ('type' in response && response.type === 'redirect') {
-      const statusText =
-        response.statusCode === 301
-          ? 'Moved Permanently'
-          : response.statusCode === 308
-            ? 'Permanent Redirect'
-            : response.statusCode === 307
-              ? 'Temporary Redirect'
-              : 'Found'
-
-      const message = `REDIRECT DETECTED: The URL redirects to a different host.
-
-Original URL: ${response.originalUrl}
-Redirect URL: ${response.redirectUrl}
-Status: ${response.statusCode} ${statusText}
-
-To complete your request, I need to fetch content from the redirected URL. Please use WebFetch again with these parameters:
-- url: "${response.redirectUrl}"
-- prompt: "${prompt}"`
-
-      const output: Output = {
-        bytes: Buffer.byteLength(message),
-        code: response.statusCode,
-        codeText: statusText,
-        result: message,
-        durationMs: Date.now() - start,
-        url,
-      }
-
-      return {
-        data: output,
-      }
-    }
-
-    const {
-      content,
-      bytes,
-      code,
-      codeText,
-      contentType,
-      persistedPath,
-      persistedSize,
-    } = response as FetchedContent
-
-    const isPreapproved = isPreapprovedUrl(url)
-
-    let result: string
-    if (
-      isPreapproved &&
-      contentType.includes('text/markdown') &&
-      content.length < MAX_MARKDOWN_LENGTH
-    ) {
-      result = content
-    } else {
-      result = await applyPromptToMarkdown(
-        prompt,
-        content,
-        abortController.signal,
-        isNonInteractiveSession,
-        isPreapproved,
-      )
-    }
-
-    // Binary content (PDFs, etc.) was additionally saved to disk with a
-    // mime-derived extension. Note it so Claude can inspect the raw file
-    // if the Haiku summary above isn't enough.
-    if (persistedPath) {
-      result += `\n\n[Binary content (${contentType}, ${formatFileSize(persistedSize ?? bytes)}) also saved to ${persistedPath}]`
-    }
-
-    const output: Output = {
-      bytes,
-      code,
-      codeText,
-      result,
-      durationMs: Date.now() - start,
-      url,
-    }
-
-    return {
-      data: output,
-    }
-  },
-  mapToolResultToToolResultBlockParam({ result }, toolUseID) {
+  call: callWebFetch,
+  mapToolResultToToolResultBlockParam({ result, sourceVerification }, toolUseID) {
     return {
       tool_use_id: toolUseID,
       type: 'tool_result',
-      content: result,
+      content: formatSourceVerifiedToolResult({ result, sourceVerification }),
     }
   },
 } satisfies ToolDef<InputSchema, Output>)

package/tui/src/tools/WebFetchTool/call.ts

@@ -0,0 +1,227 @@
+import type { ToolResult } from '../../Tool.js'
+import { errorMessage, isAbortError } from '../../utils/errors.js'
+import { formatFileSize } from '../../utils/format.js'
+import { WEB_FETCH_TOOL_NAME } from './prompt.js'
+import {
+  buildSourceEvidence,
+  buildSourceVerification,
+  redactSourceVerificationText,
+} from './sourceVerification.js'
+import type {
+  WebFetchCallContext,
+  WebFetchCallInput,
+  WebFetchOutput,
+} from './types.js'
+import { validateResolvedPublicWebFetchUrl } from './resolvedAddressSafety.js'
+import {
+  applyPromptToMarkdown,
+  getURLMarkdownContent,
+  isPreapprovedUrl,
+  MAX_MARKDOWN_LENGTH,
+} from './utils.js'
+
+export async function callWebFetch(
+  { url, prompt }: WebFetchCallInput,
+  { abortController, options: { isNonInteractiveSession } }: WebFetchCallContext,
+): Promise<ToolResult<WebFetchOutput>> {
+  const start = Date.now()
+  const validation = await validateResolvedPublicWebFetchUrl(url)
+  if (!validation.ok) {
+    return blockedToolResult({
+      url,
+      start,
+      message: `Source verification blocked: ${validation.message}`,
+      sourceUrl: null,
+      title: 'Unsafe URL',
+    })
+  }
+
+  try {
+    const response = await getURLMarkdownContent(url, abortController)
+
+    if ('type' in response && response.type === 'redirect') {
+      const redirectValidation = await validateResolvedPublicWebFetchUrl(
+        response.redirectUrl,
+      )
+      if (!redirectValidation.ok) {
+        return blockedToolResult({
+          url,
+          start,
+          code: response.statusCode,
+          codeText: 'Redirect Target Blocked',
+          message: `Source verification blocked: ${redirectValidation.message}`,
+          sourceUrl: null,
+          title: 'Unsafe redirect target',
+        })
+      }
+      return redirectedToolResult({
+        url,
+        prompt,
+        start,
+        originalUrl: response.originalUrl,
+        redirectUrl: response.redirectUrl,
+        statusCode: response.statusCode,
+      })
+    }
+
+    const {
+      content,
+      bytes,
+      code,
+      codeText,
+      contentType,
+      persistedPath,
+      persistedSize,
+    } = response
+    const isPreapproved = isPreapprovedUrl(url)
+    let result =
+      isPreapproved &&
+      contentType.includes('text/markdown') &&
+      content.length < MAX_MARKDOWN_LENGTH
+        ? content
+        : await applyPromptToMarkdown(
+            prompt,
+            content,
+            abortController.signal,
+            isNonInteractiveSession,
+            isPreapproved,
+          )
+
+    if (persistedPath) {
+      result += `\n\n[Binary content (${contentType}, ${formatFileSize(persistedSize ?? bytes)}) also saved to ${persistedPath}]`
+    }
+
+    const sourceVerification = buildSourceVerification([
+      buildSourceEvidence({
+        toolId: WEB_FETCH_TOOL_NAME,
+        sourceUrl: url,
+        title: contentType,
+        blockedOrUsed: 'needs_input',
+        rawText: result,
+      }),
+    ])
+    const safeResult = redactSourceVerificationText(result)
+
+    return {
+      data: {
+        bytes,
+        code,
+        codeText,
+        result: safeResult,
+        durationMs: Date.now() - start,
+        url,
+        sourceVerification,
+      },
+    }
+  } catch (error) {
+    if (isAbortError(error)) throw error
+    const message = `Source verification blocked: ${errorMessage(error)}`
+    return blockedToolResult({
+      url,
+      start,
+      message,
+      sourceUrl: url,
+      title: 'Provider error',
+    })
+  }
+}
+
+function redirectedToolResult({
+  url,
+  prompt,
+  start,
+  originalUrl,
+  redirectUrl,
+  statusCode,
+}: {
+  readonly url: string
+  readonly prompt: string
+  readonly start: number
+  readonly originalUrl: string
+  readonly redirectUrl: string
+  readonly statusCode: number
+}): ToolResult<WebFetchOutput> {
+  const statusText = redirectStatusText(statusCode)
+  const message = `REDIRECT DETECTED: The URL redirects to a different host.
+
+Original URL: ${originalUrl}
+Redirect URL: ${redirectUrl}
+Status: ${statusCode} ${statusText}
+
+To complete your request, I need to fetch content from the redirected URL. Please use WebFetch again with these parameters:
+- url: "${redirectUrl}"
+- prompt: "${prompt}"`
+  const safeMessage = redactSourceVerificationText(message)
+
+  return {
+    data: {
+      bytes: Buffer.byteLength(safeMessage),
+      code: statusCode,
+      codeText: statusText,
+      result: safeMessage,
+      durationMs: Date.now() - start,
+      url,
+      sourceVerification: buildSourceVerification([
+        buildSourceEvidence({
+          toolId: WEB_FETCH_TOOL_NAME,
+          sourceUrl: redirectUrl,
+          title: 'Redirect target',
+          blockedOrUsed: 'needs_input',
+          rawText: message,
+        }),
+      ]),
+    },
+  }
+}
+
+function blockedToolResult({
+  url,
+  start,
+  message,
+  sourceUrl,
+  title,
+  code = 0,
+  codeText = 'Source Verification Blocked',
+}: {
+  readonly url: string
+  readonly start: number
+  readonly message: string
+  readonly sourceUrl: string | null
+  readonly title: string
+  readonly code?: number
+  readonly codeText?: string
+}): ToolResult<WebFetchOutput> {
+  const safeMessage = redactSourceVerificationText(message)
+  return {
+    data: {
+      bytes: Buffer.byteLength(safeMessage),
+      code,
+      codeText,
+      result: safeMessage,
+      durationMs: Date.now() - start,
+      url,
+      sourceVerification: buildSourceVerification([
+        buildSourceEvidence({
+          toolId: WEB_FETCH_TOOL_NAME,
+          sourceUrl,
+          title,
+          blockedOrUsed: 'blocked',
+          rawText: message,
+        }),
+      ]),
+    },
+  }
+}
+
+function redirectStatusText(statusCode: number): string {
+  switch (statusCode) {
+    case 301:
+      return 'Moved Permanently'
+    case 307:
+      return 'Temporary Redirect'
+    case 308:
+      return 'Permanent Redirect'
+    default:
+      return 'Found'
+  }
+}