ummaya 0.2.2 → 0.2.4

package/tui/src/main.tsx

@@ -23,6 +23,7 @@ import { checkHasTrustDialogAccepted, getGlobalConfig, getRemoteControlAtStartup
 import { seedEarlyInput, stopCapturingEarlyInput } from './utils/earlyInput.js';
 import { getInitialEffortSetting, parseEffortValue } from './utils/effort.js';
 import { getInitialFastModeSetting, isFastModeEnabled, prefetchFastModeStatus, resolveFastModeStatusFromCache } from './utils/fastMode.js';
+import { getInitialReasoningModeSetting } from './utils/kExaoneReasoning.js';
 import { applyConfigEnvironmentVariables } from './utils/managedEnv.js';
 import { createSystemMessage } from './utils/systemMessageFactories.js';
 import { createUserMessage } from './utils/userMessageFactories.js';
@@ -1774,6 +1775,7 @@ async function run(): Promise<CommanderCommand> {
         },
         toolPermissionContext,
         effortValue: parseEffortValue(options.effort) ?? getInitialEffortSetting(),
+        reasoningMode: getInitialReasoningModeSetting(),
         ...(isFastModeEnabled() && {
           fastMode: getInitialFastModeSetting(effectiveModel ?? null)
         }),
@@ -2105,6 +2107,7 @@ async function run(): Promise<CommanderCommand> {
         })
       } : null,
       effortValue: parseEffortValue(options.effort) ?? getInitialEffortSetting(),
+      reasoningMode: getInitialReasoningModeSetting(),
       activeOverlays: new Set<string>(),
       fastMode: getInitialFastModeSetting(resolvedInitialModel),
       ...(isAdvisorEnabled() && advisorModel && {

package/tui/src/query.ts

@@ -99,6 +99,38 @@ import { runTools } from './services/tools/toolOrchestration.js'
 import { applyToolResultBudget } from './utils/toolResultStorage.js'
 import { recordContentReplacement } from './utils/sessionStorage.js'
 import { handleStopHooks } from './query/stopHooks.js'
+import {
+  buildNmcAedCompletionPromptIfNeeded,
+  buildNmcAedFollowupPromptIfNeeded,
+} from './tools/_shared/nmcAedGuard.js'
+import {
+  buildKmaAnalysisCompletionPromptIfNeeded,
+  buildKmaAnalysisFinalAnswerRepairPromptIfNeeded,
+  buildKmaAnalysisMissingToolPromptIfNeeded,
+  shouldWithholdKmaAnalysisToolCallText,
+} from './tools/_shared/kmaAnalysisGuard.js'
+import {
+  buildProtectedCheckCompletionPromptIfNeeded,
+  buildProtectedCheckFinalAnswerRepairPromptIfNeeded,
+  shouldWithholdProtectedCheckToolCallText,
+} from './tools/_shared/protectedCheckGuard.js'
+import {
+  buildAirKoreaCompletionPromptIfNeeded,
+  buildAirKoreaFinalAnswerRepairPromptIfNeeded,
+  buildGenericPendingFinalAnswerRepairPromptIfNeeded,
+  buildTagoBusCompletionPromptIfNeeded,
+  buildTagoBusFinalAnswerRepairPromptIfNeeded,
+  buildTagoBusFollowupPromptIfNeeded,
+  selectUmmayaToolChoiceOverride,
+  shouldWithholdAirKoreaFinalAnswer,
+  shouldWithholdGenericPendingFinalAnswer,
+  shouldWithholdTagoBusFinalAnswer,
+} from './tools/_shared/toolChoiceRepair.js'
+import {
+  buildTextToolCallFinalAnswerRepairPromptIfNeeded,
+  shouldWithholdTextToolCallFinalAnswer,
+} from './tools/_shared/textToolCallGuard.js'
+import { getAdapterToolByName } from './tools/AdapterTool/AdapterTool.js'
 import { buildQueryConfig } from './query/config.js'
 import { productionDeps, type QueryDeps } from './query/deps.js'
 import { ensureUmmayaAdapterManifest } from './ipc/bridgeSingleton.js'
@@ -679,6 +711,15 @@ async function* queryLoop(
         try {
           let streamingFallbackOccured = false
           queryCheckpoint('query_api_streaming_start')
+          const toolChoiceOverride = selectUmmayaToolChoiceOverride({
+            messages: messagesForQuery,
+            tools: toolUseContext.options.tools,
+          })
+          if (toolChoiceOverride) {
+            logForDebugging(
+              `UMMAYA tool-choice override: ${toolChoiceOverride.name}`,
+            )
+          }
           for await (const message of deps.callModel({
             messages: prependUserContext(messagesForQuery, userContext),
             systemPrompt: fullSystemPrompt,
@@ -694,7 +735,7 @@ async function* queryLoop(
               ...(config.gates.fastModeEnabled && {
                 fastMode: appState.fastMode,
               }),
-              toolChoice: undefined,
+              toolChoice: toolChoiceOverride,
               isNonInteractiveSession:
                 toolUseContext.options.isNonInteractiveSession,
               fallbackModel,
@@ -715,6 +756,7 @@ async function* queryLoop(
               ),
               queryTracking,
               effortValue: appState.effortValue,
+              reasoningMode: appState.reasoningMode,
               advisorModel: appState.advisorModel,
               skipCacheWrite,
               agentId: toolUseContext.agentId,
@@ -820,6 +862,11 @@ async function* queryLoop(
             // tree-shaking constraint), so the collapse check is nested
             // rather than composed.
             let withheld = false
+            const assistantHasToolUse =
+              message.type === 'assistant' &&
+              message.message.content.some(
+                content => content.type === 'tool_use',
+              )
             if (feature('CONTEXT_COLLAPSE')) {
               if (
                 contextCollapse?.isWithheldPromptTooLong(
@@ -843,6 +890,73 @@ async function* queryLoop(
             if (isWithheldMaxOutputTokens(message)) {
               withheld = true
             }
+            if (
+              message.type === 'assistant' &&
+              !assistantHasToolUse &&
+              shouldWithholdKmaAnalysisToolCallText({
+                messages: messagesForQuery,
+                candidate: message,
+              })
+            ) {
+              withheld = true
+            }
+            if (
+              message.type === 'assistant' &&
+              !assistantHasToolUse &&
+              shouldWithholdProtectedCheckToolCallText({
+                messages: messagesForQuery,
+                candidate: message,
+              })
+            ) {
+              withheld = true
+            }
+            if (
+              message.type === 'assistant' &&
+              !assistantHasToolUse &&
+              shouldWithholdTagoBusFinalAnswer({
+                messages: messagesForQuery,
+                candidate: message,
+              })
+            ) {
+              withheld = true
+            }
+            if (
+              message.type === 'assistant' &&
+              !assistantHasToolUse &&
+              shouldWithholdAirKoreaFinalAnswer({
+                messages: messagesForQuery,
+                candidate: message,
+              })
+            ) {
+              withheld = true
+            }
+            if (
+              message.type === 'assistant' &&
+              !assistantHasToolUse &&
+              shouldWithholdGenericPendingFinalAnswer({
+                messages: messagesForQuery,
+                candidate: message,
+              })
+            ) {
+              withheld = true
+            }
+            if (
+              message.type === 'assistant' &&
+              !assistantHasToolUse &&
+              shouldWithholdTextToolCallFinalAnswer({
+                messages: messagesForQuery,
+                candidate: message,
+              })
+            ) {
+              withheld = true
+            }
+            // Claude Code streams native tool_use blocks as visible assistant
+            // commits before tool execution. UMMAYA recovery/repair guards may
+            // withhold prose, but they must never hide the structured tool_use
+            // message that anchors the following tool_result.
+            if (assistantHasToolUse) {
+              withheld = false
+            }
             if (!withheld) {
               yield yieldMessage
             }
@@ -1287,6 +1401,220 @@ async function* queryLoop(
         return { reason: 'completed' }
       }
 
+      const kmaAnalysisMissingToolPrompt =
+        buildKmaAnalysisMissingToolPromptIfNeeded({
+          messages: [...messagesForQuery, ...assistantMessages],
+        })
+      if (kmaAnalysisMissingToolPrompt) {
+        const kmaAnalysisChartTool = getAdapterToolByName(
+          'kma_apihub_url_analysis_weather_chart_image',
+        )
+        let nextToolUseContext = toolUseContext
+        if (
+          kmaAnalysisChartTool &&
+          !toolUseContext.options.tools.some(
+            tool => tool.name === kmaAnalysisChartTool.name,
+          )
+        ) {
+          nextToolUseContext = {
+            ...toolUseContext,
+            options: {
+              ...toolUseContext.options,
+              tools: [...toolUseContext.options.tools, kmaAnalysisChartTool],
+            },
+          }
+        }
+        const next: State = {
+          messages: [
+            ...messagesForQuery,
+            ...assistantMessages,
+            createUserMessage({
+              content: kmaAnalysisMissingToolPrompt,
+              isMeta: true,
+            }),
+          ],
+          toolUseContext: nextToolUseContext,
+          autoCompactTracking: tracking,
+          maxOutputTokensRecoveryCount: 0,
+          hasAttemptedReactiveCompact,
+          maxOutputTokensOverride: undefined,
+          pendingToolUseSummary: undefined,
+          stopHookActive: true,
+          turnCount,
+          transition: { reason: 'stop_hook_blocking' },
+        }
+        state = next
+        continue
+      }
+
+      const kmaAnalysisFinalAnswerRepairPrompt =
+        buildKmaAnalysisFinalAnswerRepairPromptIfNeeded({
+          messages: [...messagesForQuery, ...assistantMessages],
+        })
+      if (kmaAnalysisFinalAnswerRepairPrompt) {
+        const next: State = {
+          messages: [
+            ...messagesForQuery,
+            ...assistantMessages,
+            createUserMessage({
+              content: kmaAnalysisFinalAnswerRepairPrompt,
+              isMeta: true,
+            }),
+          ],
+          toolUseContext,
+          autoCompactTracking: tracking,
+          maxOutputTokensRecoveryCount: 0,
+          hasAttemptedReactiveCompact,
+          maxOutputTokensOverride: undefined,
+          pendingToolUseSummary: undefined,
+          stopHookActive: true,
+          turnCount,
+          transition: { reason: 'stop_hook_blocking' },
+        }
+        state = next
+        continue
+      }
+
+      const protectedCheckFinalAnswerRepairPrompt =
+        buildProtectedCheckFinalAnswerRepairPromptIfNeeded({
+          messages: [...messagesForQuery, ...assistantMessages],
+        })
+      if (protectedCheckFinalAnswerRepairPrompt) {
+        const next: State = {
+          messages: [
+            ...messagesForQuery,
+            ...assistantMessages,
+            createUserMessage({
+              content: protectedCheckFinalAnswerRepairPrompt,
+              isMeta: true,
+            }),
+          ],
+          toolUseContext,
+          autoCompactTracking: tracking,
+          maxOutputTokensRecoveryCount: 0,
+          hasAttemptedReactiveCompact,
+          maxOutputTokensOverride: undefined,
+          pendingToolUseSummary: undefined,
+          stopHookActive: true,
+          turnCount,
+          transition: { reason: 'stop_hook_blocking' },
+        }
+        state = next
+        continue
+      }
+
+      const airKoreaFinalAnswerRepairPrompt =
+        buildAirKoreaFinalAnswerRepairPromptIfNeeded({
+          messages: [...messagesForQuery, ...assistantMessages],
+        })
+      if (airKoreaFinalAnswerRepairPrompt) {
+        const next: State = {
+          messages: [
+            ...messagesForQuery,
+            ...assistantMessages,
+            createUserMessage({
+              content: airKoreaFinalAnswerRepairPrompt,
+              isMeta: true,
+            }),
+          ],
+          toolUseContext,
+          autoCompactTracking: tracking,
+          maxOutputTokensRecoveryCount: 0,
+          hasAttemptedReactiveCompact,
+          maxOutputTokensOverride: undefined,
+          pendingToolUseSummary: undefined,
+          stopHookActive: true,
+          turnCount,
+          transition: { reason: 'stop_hook_blocking' },
+        }
+        state = next
+        continue
+      }
+
+      const tagoBusFinalAnswerRepairPrompt =
+        buildTagoBusFinalAnswerRepairPromptIfNeeded({
+          messages: [...messagesForQuery, ...assistantMessages],
+        })
+      if (tagoBusFinalAnswerRepairPrompt) {
+        const next: State = {
+          messages: [
+            ...messagesForQuery,
+            ...assistantMessages,
+            createUserMessage({
+              content: tagoBusFinalAnswerRepairPrompt,
+              isMeta: true,
+            }),
+          ],
+          toolUseContext,
+          autoCompactTracking: tracking,
+          maxOutputTokensRecoveryCount: 0,
+          hasAttemptedReactiveCompact,
+          maxOutputTokensOverride: undefined,
+          pendingToolUseSummary: undefined,
+          stopHookActive: true,
+          turnCount,
+          transition: { reason: 'stop_hook_blocking' },
+        }
+        state = next
+        continue
+      }
+
+      const textToolCallFinalAnswerRepairPrompt =
+        buildTextToolCallFinalAnswerRepairPromptIfNeeded({
+          messages: [...messagesForQuery, ...assistantMessages],
+        })
+      if (textToolCallFinalAnswerRepairPrompt) {
+        const next: State = {
+          messages: [
+            ...messagesForQuery,
+            ...assistantMessages,
+            createUserMessage({
+              content: textToolCallFinalAnswerRepairPrompt,
+              isMeta: true,
+            }),
+          ],
+          toolUseContext,
+          autoCompactTracking: tracking,
+          maxOutputTokensRecoveryCount: 0,
+          hasAttemptedReactiveCompact,
+          maxOutputTokensOverride: undefined,
+          pendingToolUseSummary: undefined,
+          stopHookActive: true,
+          turnCount,
+          transition: { reason: 'stop_hook_blocking' },
+        }
+        state = next
+        continue
+      }
+
+      const genericPendingFinalAnswerRepairPrompt =
+        buildGenericPendingFinalAnswerRepairPromptIfNeeded({
+          messages: [...messagesForQuery, ...assistantMessages],
+        })
+      if (genericPendingFinalAnswerRepairPrompt) {
+        const next: State = {
+          messages: [
+            ...messagesForQuery,
+            ...assistantMessages,
+            createUserMessage({
+              content: genericPendingFinalAnswerRepairPrompt,
+              isMeta: true,
+            }),
+          ],
+          toolUseContext,
+          autoCompactTracking: tracking,
+          maxOutputTokensRecoveryCount: 0,
+          hasAttemptedReactiveCompact,
+          maxOutputTokensOverride: undefined,
+          pendingToolUseSummary: undefined,
+          stopHookActive: true,
+          turnCount,
+          transition: { reason: 'stop_hook_blocking' },
+        }
+        state = next
+        continue
+      }
+
       const stopHookResult = yield* handleStopHooks(
         messagesForQuery,
         assistantMessages,
@@ -1385,7 +1713,6 @@ async function* queryLoop(
 
     queryCheckpoint('query_tool_execution_start')
 
-
     if (streamingToolExecutor) {
       logEvent('tengu_streaming_tool_execution_used', {
         tool_count: toolUseBlocks.length,
@@ -1693,6 +2020,144 @@ async function* queryLoop(
       }
     }
 
+    const nmcAedMessages = [...messagesForQuery, ...assistantMessages, ...toolResults]
+    const nmcAedTool = getAdapterToolByName('nmc_aed_site_locate')
+    const nmcRegionTool = getAdapterToolByName('kakao_coord_to_region')
+    const nmcAedAvailableToolNames = new Set(
+      updatedToolUseContext.options.tools.map(tool => tool.name),
+    )
+    if (nmcAedTool) {
+      nmcAedAvailableToolNames.add(nmcAedTool.name)
+    }
+    if (nmcRegionTool) {
+      nmcAedAvailableToolNames.add(nmcRegionTool.name)
+    }
+    const missingNmcHelperTools = [nmcAedTool, nmcRegionTool].filter(
+      (tool): tool is NonNullable<ReturnType<typeof getAdapterToolByName>> =>
+        Boolean(tool) &&
+        !updatedToolUseContext.options.tools.some(existing => existing.name === tool.name),
+    )
+    if (missingNmcHelperTools.length > 0) {
+      updatedToolUseContext = {
+        ...updatedToolUseContext,
+        options: {
+          ...updatedToolUseContext.options,
+          tools: [...updatedToolUseContext.options.tools, ...missingNmcHelperTools],
+        },
+      }
+    }
+    const nmcAedFollowupPrompt = buildNmcAedFollowupPromptIfNeeded({
+      messages: nmcAedMessages,
+      availableToolNames: nmcAedAvailableToolNames,
+    })
+    if (nmcAedFollowupPrompt) {
+      toolResults.push(
+        createUserMessage({
+          content: nmcAedFollowupPrompt,
+          isMeta: true,
+        }),
+      )
+    } else {
+      const tagoBusMessages = [...messagesForQuery, ...assistantMessages, ...toolResults]
+      const tagoBusTools = [
+        getAdapterToolByName('tago_bus_route_search'),
+        getAdapterToolByName('tago_bus_route_station_search'),
+        getAdapterToolByName('tago_bus_arrival_search'),
+      ].filter(
+        (tool): tool is NonNullable<ReturnType<typeof getAdapterToolByName>> =>
+          Boolean(tool),
+      )
+      const tagoBusAvailableToolNames = new Set(
+        updatedToolUseContext.options.tools.map(tool => tool.name),
+      )
+      for (const tool of tagoBusTools) {
+        tagoBusAvailableToolNames.add(tool.name)
+      }
+      const tagoBusFollowupPrompt = buildTagoBusFollowupPromptIfNeeded({
+        messages: tagoBusMessages,
+        availableToolNames: tagoBusAvailableToolNames,
+      })
+      if (tagoBusFollowupPrompt) {
+        const existingToolNames = new Set(
+          updatedToolUseContext.options.tools.map(tool => tool.name),
+        )
+        const missingTagoBusTools = tagoBusTools.filter(
+          tool => !existingToolNames.has(tool.name),
+        )
+        if (missingTagoBusTools.length > 0) {
+          updatedToolUseContext = {
+            ...updatedToolUseContext,
+            options: {
+              ...updatedToolUseContext.options,
+              tools: [...updatedToolUseContext.options.tools, ...missingTagoBusTools],
+            },
+          }
+        }
+        toolResults.push(
+          createUserMessage({
+            content: tagoBusFollowupPrompt,
+            isMeta: true,
+          }),
+        )
+      } else {
+        const nmcAedCompletionPrompt = buildNmcAedCompletionPromptIfNeeded({
+          messages: [...messagesForQuery, ...assistantMessages, ...toolResults],
+        })
+        if (nmcAedCompletionPrompt) {
+          toolResults.push(
+            createUserMessage({
+              content: nmcAedCompletionPrompt,
+              isMeta: true,
+            }),
+          )
+        }
+        const tagoBusCompletionPrompt = buildTagoBusCompletionPromptIfNeeded({
+          messages: [...messagesForQuery, ...assistantMessages, ...toolResults],
+        })
+        if (tagoBusCompletionPrompt) {
+          toolResults.push(
+            createUserMessage({
+              content: tagoBusCompletionPrompt,
+              isMeta: true,
+            }),
+          )
+        }
+        const protectedCheckCompletionPrompt = buildProtectedCheckCompletionPromptIfNeeded({
+          messages: [...messagesForQuery, ...assistantMessages, ...toolResults],
+        })
+        if (protectedCheckCompletionPrompt) {
+          toolResults.push(
+            createUserMessage({
+              content: protectedCheckCompletionPrompt,
+              isMeta: true,
+            }),
+          )
+        }
+        const kmaAnalysisCompletionPrompt = buildKmaAnalysisCompletionPromptIfNeeded({
+          messages: [...messagesForQuery, ...assistantMessages, ...toolResults],
+        })
+        if (kmaAnalysisCompletionPrompt) {
+          toolResults.push(
+            createUserMessage({
+              content: kmaAnalysisCompletionPrompt,
+              isMeta: true,
+            }),
+          )
+        }
+        const airKoreaCompletionPrompt = buildAirKoreaCompletionPromptIfNeeded({
+          messages: [...messagesForQuery, ...assistantMessages, ...toolResults],
+        })
+        if (airKoreaCompletionPrompt) {
+          toolResults.push(
+            createUserMessage({
+              content: airKoreaCompletionPrompt,
+              isMeta: true,
+            }),
+          )
+        }
+      }
+    }
+
     const toolUseContextWithQueryTracking = {
       ...updatedToolUseContext,
       queryTracking,

package/tui/src/screens/REPL.tsx

@@ -2671,7 +2671,7 @@ export function REPL({
       }
     }
 
-    // Mark onboarding as complete when any user message is sent to Claude
+    // Mark onboarding as complete when any user message is sent to UMMAYA.
     void maybeMarkProjectOnboardingComplete();
 
     // Extract a session title from the first real user message. One-shot
@@ -3932,7 +3932,7 @@ export function REPL({
       // Use ref to get current dialog state, avoiding stale closure
       focusedInputDialogRef.current === undefined && idleTimeSinceResponse >= getGlobalConfig().messageIdleNotifThresholdMs) {
         void sendNotification({
-          message: 'Claude is waiting for your input',
+          message: 'UMMAYA is waiting for your input',
           notificationType: 'idle_prompt'
         }, terminal);
       }
@@ -4893,7 +4893,7 @@ export function REPL({
 
                 {!toolJSX?.shouldHidePromptInput && !focusedInputDialog && !isExiting && !disabled && !cursor && <>
                       {autoRunIssueReason && <AutoRunIssueNotification onRun={handleAutoRunIssue} onCancel={handleCancelAutoRunIssue} reason={getAutoRunIssueReasonText(autoRunIssueReason)} />}
-                      {postCompactSurvey.state !== 'closed' ? <FeedbackSurvey state={postCompactSurvey.state} lastResponse={postCompactSurvey.lastResponse} handleSelect={postCompactSurvey.handleSelect} inputValue={inputValue} setInputValue={setInputValue} onRequestFeedback={handleSurveyRequestFeedback} /> : memorySurvey.state !== 'closed' ? <FeedbackSurvey state={memorySurvey.state} lastResponse={memorySurvey.lastResponse} handleSelect={memorySurvey.handleSelect} handleTranscriptSelect={memorySurvey.handleTranscriptSelect} inputValue={inputValue} setInputValue={setInputValue} onRequestFeedback={handleSurveyRequestFeedback} message="How well did Claude use its memory? (optional)" /> : <FeedbackSurvey state={feedbackSurvey.state} lastResponse={feedbackSurvey.lastResponse} handleSelect={feedbackSurvey.handleSelect} handleTranscriptSelect={feedbackSurvey.handleTranscriptSelect} inputValue={inputValue} setInputValue={setInputValue} onRequestFeedback={didAutoRunIssueRef.current ? undefined : handleSurveyRequestFeedback} />}
+                      {postCompactSurvey.state !== 'closed' ? <FeedbackSurvey state={postCompactSurvey.state} lastResponse={postCompactSurvey.lastResponse} handleSelect={postCompactSurvey.handleSelect} inputValue={inputValue} setInputValue={setInputValue} onRequestFeedback={handleSurveyRequestFeedback} /> : memorySurvey.state !== 'closed' ? <FeedbackSurvey state={memorySurvey.state} lastResponse={memorySurvey.lastResponse} handleSelect={memorySurvey.handleSelect} handleTranscriptSelect={memorySurvey.handleTranscriptSelect} inputValue={inputValue} setInputValue={setInputValue} onRequestFeedback={handleSurveyRequestFeedback} message="How well did UMMAYA use its memory? (optional)" /> : <FeedbackSurvey state={feedbackSurvey.state} lastResponse={feedbackSurvey.lastResponse} handleSelect={feedbackSurvey.handleSelect} handleTranscriptSelect={feedbackSurvey.handleTranscriptSelect} inputValue={inputValue} setInputValue={setInputValue} onRequestFeedback={didAutoRunIssueRef.current ? undefined : handleSurveyRequestFeedback} />}
                       {/* Frustration-triggered transcript sharing prompt */}
                       {frustrationDetection.state !== 'closed' && <FeedbackSurvey state={frustrationDetection.state} lastResponse={null} handleSelect={() => {}} handleTranscriptSelect={frustrationDetection.handleTranscriptSelect} inputValue={inputValue} setInputValue={setInputValue} />}
                       {/* Skill improvement survey - appears when improvements detected (ant-only) */}