ummaya 0.2.4 → 0.2.5

package/tui/src/query/supportBoundary.ts

@@ -0,0 +1,168 @@
+import { createAssistantMessage } from '../utils/messages.js'
+import type { AssistantMessage, Message } from '../types/message.js'
+import {
+  buildIgnoredDocumentToolChoiceBlockedText,
+  buildIgnoredSupportToolChoiceBlockedText,
+  scrubIgnoredSupportToolChoiceMessage,
+  shouldWithholdIgnoredDocumentToolChoiceText,
+  shouldWithholdIgnoredSupportToolChoiceText,
+} from '../tools/_shared/toolChoiceRepair.js'
+import { selectRecoveredSupportToolNamesForQuery } from '../tools/ToolSearchTool/supportIntentHints.js'
+import {
+  cloneAssistantWithoutText,
+  contentBlocks,
+  hasAssistantToolUseNamedAfterLatestTextUser,
+  latestTextUserMessageIndex,
+  messageText,
+  toolUseBlocks,
+} from './messageGuards.js'
+
+const ADAPTERLESS_FIND_FAILURE_RE =
+  /find\(mode='fetch'\) requires a concrete adapter tool_id|No concrete adapter was selected|requires a concrete adapter tool_id|Missing or invalid fields:\s*tool_id/iu
+const WORKSPACE_READ_SUMMARY_RE =
+  /\bRead\s+\d+\s+files?\b(?:\s+\(ctrl\+o to expand\))?/iu
+
+export type SupportBoundaryResult =
+  | { readonly kind: 'pass'; readonly message: AssistantMessage }
+  | { readonly kind: 'block'; readonly message: AssistantMessage }
+
+function shouldWithholdIgnoredToolChoiceText(params: {
+  readonly toolChoiceName: string
+  readonly candidate: unknown
+}): boolean {
+  return shouldWithholdIgnoredSupportToolChoiceText(params) ||
+    shouldWithholdIgnoredDocumentToolChoiceText(params)
+}
+
+function buildIgnoredToolChoiceBlockedText(
+  toolChoiceName: string,
+  toolChoiceAvailable: boolean,
+): string {
+  if (shouldWithholdIgnoredDocumentToolChoiceText({
+    toolChoiceName,
+    candidate: 'document-boundary',
+  })) {
+    return buildIgnoredDocumentToolChoiceBlockedText(toolChoiceAvailable)
+  }
+  return buildIgnoredSupportToolChoiceBlockedText(
+    toolChoiceName,
+    toolChoiceAvailable,
+  )
+}
+
+function toolResultContentText(block: Record<string, unknown>): string {
+  if (block.type !== 'tool_result') return ''
+  return typeof block.content === 'string' ? block.content : ''
+}
+
+function hasAdapterlessFindFailure(messages: readonly Message[]): boolean {
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index]
+    if (!message) continue
+    for (const block of contentBlocks(message)) {
+      if (ADAPTERLESS_FIND_FAILURE_RE.test(toolResultContentText(block))) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+function latestUserRequestsWorkspaceRead(messages: readonly Message[]): boolean {
+  const latestUserIndex = latestTextUserMessageIndex(messages)
+  if (latestUserIndex < 0) return false
+  const latestUserMessage = messages[latestUserIndex]
+  if (!latestUserMessage) return false
+  return selectRecoveredSupportToolNamesForQuery(
+    messageText(latestUserMessage),
+  ).includes('workspace_read')
+}
+
+function shouldBlockAdapterlessFindWorkspaceSummary(params: {
+  readonly messagesForQuery: readonly Message[]
+  readonly assistantMessage: AssistantMessage
+}): boolean {
+  if (latestUserRequestsWorkspaceRead(params.messagesForQuery)) return false
+  return hasAdapterlessFindFailure(params.messagesForQuery) &&
+    WORKSPACE_READ_SUMMARY_RE.test(messageText(params.assistantMessage))
+}
+
+function buildAdapterlessFindWorkspaceBlockedText(): string {
+  return [
+    '공공서비스 adapter 선택 차단: root find가 구체적인 adapter tool_id 없이 실패했습니다.',
+    '로컬 파일/워크스페이스 결과는 이 시민 업무의 근거로 사용하지 않습니다.',
+    '사용 가능한 출생신고, 아동수당, 첫만남이용권, 건강보험 피부양자 adapter가 로드되면 이어서 진행하고, 현재는 공식 기관 채널 확인 또는 필요한 adapter/credential 준비가 필요합니다.',
+  ].join(' ')
+}
+
+export function enforceSupportToolBoundary(params: {
+  readonly activeToolChoiceName: string | undefined
+  readonly activeToolChoiceAvailable: boolean
+  readonly messagesForQuery: readonly Message[]
+  readonly assistantMessage: AssistantMessage
+}): SupportBoundaryResult {
+  const { activeToolChoiceName, assistantMessage, messagesForQuery } = params
+  if (
+    shouldBlockAdapterlessFindWorkspaceSummary({
+      messagesForQuery,
+      assistantMessage,
+    })
+  ) {
+    return {
+      kind: 'block',
+      message: createAssistantMessage({
+        content: buildAdapterlessFindWorkspaceBlockedText(),
+      }),
+    }
+  }
+  if (!activeToolChoiceName) return { kind: 'pass', message: assistantMessage }
+
+  const currentToolUseExists = toolUseBlocks(assistantMessage).some(
+    block => block.name === activeToolChoiceName,
+  )
+  if (currentToolUseExists) {
+    const scrubbed = scrubIgnoredSupportToolChoiceMessage({
+      toolChoiceName: activeToolChoiceName,
+      candidate: messageText(assistantMessage),
+    })
+    const shouldScrubDocumentText = shouldWithholdIgnoredDocumentToolChoiceText({
+      toolChoiceName: activeToolChoiceName,
+      candidate: messageText(assistantMessage),
+    })
+    return {
+      kind: 'pass',
+      message:
+        scrubbed === undefined && !shouldScrubDocumentText
+          ? assistantMessage
+          : cloneAssistantWithoutText(assistantMessage),
+    }
+  }
+
+  if (
+    hasAssistantToolUseNamedAfterLatestTextUser(
+      messagesForQuery,
+      activeToolChoiceName,
+    )
+  ) {
+    return { kind: 'pass', message: assistantMessage }
+  }
+
+  if (
+    shouldWithholdIgnoredToolChoiceText({
+      toolChoiceName: activeToolChoiceName,
+      candidate: messageText(assistantMessage),
+    })
+  ) {
+    return {
+      kind: 'block',
+      message: createAssistantMessage({
+        content: buildIgnoredToolChoiceBlockedText(
+          activeToolChoiceName,
+          params.activeToolChoiceAvailable,
+        ),
+      }),
+    }
+  }
+
+  return { kind: 'pass', message: assistantMessage }
+}

package/tui/src/query/toolResultErrors.ts

@@ -0,0 +1,103 @@
+export const TOOL_RESULT_ERROR_CODES = {
+  toolUnavailable: 'tool_unavailable',
+} as const
+
+export type ToolUnavailableErrorPayload = {
+  readonly ok: false
+  readonly error: {
+    readonly code: typeof TOOL_RESULT_ERROR_CODES.toolUnavailable
+    readonly tool_name: string
+  }
+}
+
+const ADAPTER_NOT_FOUND_RE =
+  /AdapterNotFound:\s*'([^']+)'\s+is not in the synced backend manifest or the internal tools list/iu
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function parseJsonRecord(value: string): Record<string, unknown> | undefined {
+  try {
+    const parsed: unknown = JSON.parse(value)
+    return isRecord(parsed) ? parsed : undefined
+  } catch {
+    return undefined
+  }
+}
+
+function recordFromValue(value: unknown): Record<string, unknown> | undefined {
+  if (typeof value === 'string') return parseJsonRecord(value)
+  return isRecord(value) ? value : undefined
+}
+
+function adapterNameFromText(value: string): string | undefined {
+  const match = ADAPTER_NOT_FOUND_RE.exec(value)
+  const name = match?.[1]?.trim()
+  return name && name.length > 0 ? name : undefined
+}
+
+function firstString(...values: readonly unknown[]): string | undefined {
+  return values.find((value): value is string =>
+    typeof value === 'string' && value.trim().length > 0
+  )
+}
+
+export function createToolUnavailableErrorPayload(
+  toolName: string,
+): ToolUnavailableErrorPayload {
+  return {
+    ok: false,
+    error: {
+      code: TOOL_RESULT_ERROR_CODES.toolUnavailable,
+      tool_name: toolName,
+    },
+  }
+}
+
+export function parseAdapterNotFoundToolName(value: unknown): string | undefined {
+  if (typeof value === 'string') return adapterNameFromText(value)
+  const record = recordFromValue(value)
+  if (record === undefined) return undefined
+
+  const error = isRecord(record.error) ? record.error : undefined
+  const message = firstString(
+    error?.message,
+    record.message,
+    record.toolUseResult,
+  )
+  const fromMessage = message !== undefined
+    ? adapterNameFromText(message)
+    : undefined
+  if (fromMessage !== undefined) return fromMessage
+
+  const code = firstString(error?.code, record.errorCode)
+  const toolName = firstString(
+    error?.tool_name,
+    record.tool_name,
+    record.tool_id,
+  )
+  return code === 'AdapterNotFound' ? toolName : undefined
+}
+
+export function parseToolUnavailableError(
+  value: unknown,
+): ToolUnavailableErrorPayload | undefined {
+  const record = recordFromValue(value)
+  if (record === undefined || record.ok !== false) return undefined
+
+  const error = isRecord(record.error) ? record.error : undefined
+  if (error === undefined) return undefined
+
+  const code = error.code
+  const toolName = error.tool_name
+  if (
+    code !== TOOL_RESULT_ERROR_CODES.toolUnavailable ||
+    typeof toolName !== 'string' ||
+    toolName.trim().length === 0
+  ) {
+    return undefined
+  }
+
+  return createToolUnavailableErrorPayload(toolName)
+}