ummaya 0.2.3 → 0.2.5

package/tui/src/utils/rawJsonToolCall.ts

@@ -0,0 +1,242 @@
+export type RawJsonToolCallProposal = {
+  readonly name: string
+  readonly input: Record<string, unknown>
+}
+
+export const RAW_JSON_REGISTERED_TOOL_USE_ID_PREFIX = 'call_raw_json_tool_'
+export const RAW_JSON_UNREGISTERED_TOOL_USE_ID_PREFIX =
+  'call_raw_json_unregistered_tool_'
+
+export function isUnregisteredRawJsonToolUseId(id: string): boolean {
+  return id.startsWith(RAW_JSON_UNREGISTERED_TOOL_USE_ID_PREFIX)
+}
+
+export type RawJsonToolCallMalformedReason =
+  | 'invalid_json'
+  | 'top_level_contract_mismatch'
+  | 'name_contract_mismatch'
+  | 'arguments_contract_mismatch'
+
+export type RawJsonToolCallNonProposalReason =
+  | 'not_exact_top_level_json'
+  | 'not_tool_like_json'
+
+export type RawJsonToolCallClassification =
+  | { readonly kind: 'registered'; readonly executable: true; readonly proposal: RawJsonToolCallProposal }
+  | { readonly kind: 'unregistered'; readonly executable: false; readonly proposal: RawJsonToolCallProposal }
+  | { readonly kind: 'malformed_input'; readonly executable: false; readonly reason: RawJsonToolCallMalformedReason }
+  | { readonly kind: 'non_proposal'; readonly executable: false; readonly reason: RawJsonToolCallNonProposalReason }
+
+type ExactRawJsonToolCallParseResult =
+  | { readonly kind: 'proposal'; readonly proposal: RawJsonToolCallProposal }
+  | { readonly kind: 'malformed_input'; readonly reason: RawJsonToolCallMalformedReason }
+  | { readonly kind: 'non_proposal'; readonly reason: RawJsonToolCallNonProposalReason }
+
+export type TrailingRawJsonToolCallProposal = {
+  readonly prelude: string
+  readonly proposal: RawJsonToolCallProposal
+}
+
+export type TextualToolCallProposalExtraction = {
+  readonly text: string
+  readonly proposals: readonly RawJsonToolCallProposal[]
+}
+
+const TOOL_CALL_OPEN = '<tool_call>'
+const TOOL_CALL_CLOSE = '</tool_call>'
+const RAW_JSON_TOOL_CALL_KEY_START_RE =
+  /^\s*\{\s*["'](?:name|tool)["']\s*:\s*["'][^"']+["']/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 parseArguments(value: unknown): Record<string, unknown> | undefined {
+  if (isRecord(value)) return value
+  if (typeof value !== 'string') return undefined
+  return parseJsonRecord(value)
+}
+
+function isToolLikeRecord(value: Record<string, unknown>): boolean {
+  const topLevelKeys = Object.keys(value)
+  return topLevelKeys.includes('name') ||
+    topLevelKeys.includes('tool') ||
+    topLevelKeys.includes('arguments')
+}
+
+function parseExactRawJsonToolCallProposal(params: {
+  readonly text: string
+}): ExactRawJsonToolCallParseResult {
+  const trimmed = params.text.trim()
+  if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
+    return { kind: 'non_proposal', reason: 'not_exact_top_level_json' }
+  }
+
+  const parsed = parseJsonRecord(trimmed)
+  if (parsed === undefined) {
+    if (RAW_JSON_TOOL_CALL_KEY_START_RE.test(trimmed)) {
+      return { kind: 'malformed_input', reason: 'invalid_json' }
+    }
+    return { kind: 'non_proposal', reason: 'not_tool_like_json' }
+  }
+
+  const topLevelKeys = Object.keys(parsed)
+  if (
+    topLevelKeys.length !== 2 ||
+    !topLevelKeys.includes('name') ||
+    !topLevelKeys.includes('arguments')
+  ) {
+    return isToolLikeRecord(parsed)
+      ? { kind: 'malformed_input', reason: 'top_level_contract_mismatch' }
+      : { kind: 'non_proposal', reason: 'not_tool_like_json' }
+  }
+
+  const name = parsed.name
+  if (typeof name !== 'string' || name.trim().length === 0) {
+    return { kind: 'malformed_input', reason: 'name_contract_mismatch' }
+  }
+
+  const input = parseArguments(parsed.arguments)
+  if (input === undefined) {
+    return { kind: 'malformed_input', reason: 'arguments_contract_mismatch' }
+  }
+  return { kind: 'proposal', proposal: { name, input } }
+}
+
+export function classifyRawJsonToolCallProposal(params: {
+  readonly text: string
+  readonly availableToolNames: readonly string[]
+}): RawJsonToolCallClassification {
+  const result = parseExactRawJsonToolCallProposal({ text: params.text })
+  switch (result.kind) {
+    case 'proposal': {
+      const availableToolNames = new Set(params.availableToolNames)
+      return availableToolNames.has(result.proposal.name)
+        ? {
+            kind: 'registered',
+            executable: true,
+            proposal: result.proposal,
+          }
+        : {
+            kind: 'unregistered',
+            executable: false,
+            proposal: result.proposal,
+          }
+    }
+    case 'malformed_input':
+      return { kind: 'malformed_input', executable: false, reason: result.reason }
+    case 'non_proposal':
+      return { kind: 'non_proposal', executable: false, reason: result.reason }
+  }
+}
+
+export function parseRawJsonToolCallProposal(params: {
+  readonly text: string
+}): RawJsonToolCallProposal | undefined {
+  const result = parseExactRawJsonToolCallProposal(params)
+  switch (result.kind) {
+    case 'proposal':
+      return result.proposal
+    case 'malformed_input':
+    case 'non_proposal':
+      return undefined
+  }
+}
+
+export function parseTrailingRawJsonToolCallProposal(params: {
+  readonly text: string
+}): TrailingRawJsonToolCallProposal | undefined {
+  const trimmedEnd = params.text.trimEnd()
+  let candidateStart = trimmedEnd.lastIndexOf('{')
+  while (candidateStart >= 0) {
+    const proposal = parseRawJsonToolCallProposal({
+      text: trimmedEnd.slice(candidateStart),
+    })
+    if (proposal !== undefined) {
+      return {
+        prelude: trimmedEnd.slice(0, candidateStart).trimEnd(),
+        proposal,
+      }
+    }
+    if (candidateStart === 0) break
+    candidateStart = trimmedEnd.lastIndexOf('{', candidateStart - 1)
+  }
+  return undefined
+}
+
+export function extractTextualToolCallProposals(params: {
+  readonly text: string
+}): TextualToolCallProposalExtraction | undefined {
+  let searchStart = 0
+  let cleanedText = ''
+  const proposals: RawJsonToolCallProposal[] = []
+
+  while (searchStart < params.text.length) {
+    const openIndex = params.text.indexOf(TOOL_CALL_OPEN, searchStart)
+    if (openIndex < 0) {
+      cleanedText += params.text.slice(searchStart)
+      break
+    }
+
+    const payloadStart = openIndex + TOOL_CALL_OPEN.length
+    const closeIndex = params.text.indexOf(TOOL_CALL_CLOSE, payloadStart)
+    if (closeIndex < 0) {
+      return undefined
+    }
+
+    const proposal = parseRawJsonToolCallProposal({
+      text: params.text.slice(payloadStart, closeIndex),
+    })
+    if (proposal === undefined) {
+      return undefined
+    }
+
+    cleanedText += params.text.slice(searchStart, openIndex)
+    proposals.push(proposal)
+    searchStart = closeIndex + TOOL_CALL_CLOSE.length
+  }
+
+  if (proposals.length === 0) return undefined
+  return {
+    text: cleanedText.trimEnd(),
+    proposals,
+  }
+}
+
+export function textContainsToolCallProposal(text: string): boolean {
+  return extractTextualToolCallProposals({ text }) !== undefined ||
+    parseTrailingRawJsonToolCallProposal({ text }) !== undefined
+}
+
+export function textContainsMalformedToolCallProposal(text: string): boolean {
+  if (textContainsToolCallProposal(text)) return false
+  if (text.includes(TOOL_CALL_OPEN)) return true
+
+  const trimmedEnd = text.trimEnd()
+  let candidateStart = trimmedEnd.lastIndexOf('{')
+  while (candidateStart >= 0) {
+    const candidate = trimmedEnd.slice(candidateStart)
+    if (RAW_JSON_TOOL_CALL_KEY_START_RE.test(candidate)) {
+      return parseJsonRecord(candidate) === undefined
+    }
+    if (candidateStart === 0) break
+    candidateStart = trimmedEnd.lastIndexOf('{', candidateStart - 1)
+  }
+  return false
+}
+
+export function stripToolCallProposalText(text: string): string {
+  const textual = extractTextualToolCallProposals({ text })
+  if (textual !== undefined) return textual.text
+  const trailing = parseTrailingRawJsonToolCallProposal({ text })
+  return trailing?.prelude ?? text
+}

package/tui/src/utils/ripgrep.ts

@@ -1,5 +1,6 @@
 import type { ChildProcess, ExecFileException } from 'child_process'
 import { execFile, spawn } from 'child_process'
+import { existsSync } from 'fs'
 import memoize from 'lodash-es/memoize.js'
 import { homedir } from 'os'
 import * as path from 'path'
@@ -28,6 +29,14 @@ type RipgrepConfig = {
   argv0?: string
 }
 
+function systemRipgrepConfig(): RipgrepConfig | undefined {
+  const { cmd: systemPath } = findExecutable('rg', [])
+  if (systemPath === 'rg') return undefined
+  // SECURITY: Use command name 'rg' instead of systemPath to prevent PATH hijacking.
+  // If we used systemPath, a malicious ./rg.exe in cwd could be executed.
+  return { mode: 'system', command: 'rg', args: [] }
+}
+
 const getRipgrepConfig = memoize((): RipgrepConfig => {
   const userWantsSystemRipgrep = isEnvDefinedFalsy(
     process.env.USE_BUILTIN_RIPGREP,
@@ -35,13 +44,8 @@ const getRipgrepConfig = memoize((): RipgrepConfig => {
 
   // Try system ripgrep if user wants it
   if (userWantsSystemRipgrep) {
-    const { cmd: systemPath } = findExecutable('rg', [])
-    if (systemPath !== 'rg') {
-      // SECURITY: Use command name 'rg' instead of systemPath to prevent PATH hijacking
-      // If we used systemPath, a malicious ./rg.exe in current directory could be executed
-      // Using just 'rg' lets the OS resolve it safely with NoDefaultCurrentDirectoryInExePath protection
-      return { mode: 'system', command: 'rg', args: [] }
-    }
+    const systemConfig = systemRipgrepConfig()
+    if (systemConfig) return systemConfig
   }
 
   // In bundled (native) mode, ripgrep is statically compiled into bun-internal
@@ -61,6 +65,11 @@ const getRipgrepConfig = memoize((): RipgrepConfig => {
       ? path.resolve(rgRoot, `${process.arch}-win32`, 'rg.exe')
       : path.resolve(rgRoot, `${process.arch}-${process.platform}`, 'rg')
 
+  if (!existsSync(command)) {
+    const systemConfig = systemRipgrepConfig()
+    if (systemConfig) return systemConfig
+  }
+
   return { mode: 'builtin', command, args: [] }
 })
 

package/tui/src/utils/sessionTitle.ts

@@ -15,7 +15,7 @@
 import { z } from 'zod/v4'
 import { getIsNonInteractiveSession } from '../bootstrap/state.js'
 import { logEvent } from '../services/analytics/index.js'
-import { queryHaiku } from '../services/api/claude.js'
+import { queryHaiku } from '../services/api/ummaya.js'
 import type { Message } from '../types/message.js'
 import { logForDebugging } from './debug.js'
 import { safeParseJSON } from './json.js'

package/tui/src/utils/settings/applySettingsChange.ts

@@ -74,6 +74,9 @@ export function applySettingsChange(
     const prevEffort = prev.settings.effortLevel
     const newEffort = newSettings.effortLevel
     const effortChanged = prevEffort !== newEffort
+    const prevReasoningMode = prev.settings.reasoningMode
+    const newReasoningMode = newSettings.reasoningMode
+    const reasoningModeChanged = prevReasoningMode !== newReasoningMode
 
     return {
       ...prev,
@@ -87,6 +90,7 @@ export function applySettingsChange(
       ...(effortChanged && newEffort !== undefined
         ? { effortValue: newEffort }
         : {}),
+      ...(reasoningModeChanged ? { reasoningMode: newReasoningMode } : {}),
     }
   })
 }

package/tui/src/utils/settings/permissionValidation.ts

@@ -134,8 +134,14 @@ export function validatePermissionRule(rule: string): {
     return { valid: false, error: 'Tool name cannot be empty' }
   }
 
-  // Check tool name starts with uppercase (standard tools)
-  if (parsed.toolName[0] !== parsed.toolName[0]?.toUpperCase()) {
+  // Check tool name starts with uppercase (Claude Code standard tools).
+  // UMMAYA's sanctioned tool-surface swap exposes lowercase primitive and
+  // adapter names such as `document` and `workspace_glob`; those are valid
+  // first-class tools, not malformed CC tool names.
+  if (
+    parsed.toolName[0] !== parsed.toolName[0]?.toUpperCase() &&
+    !isUmmayaLowercaseToolName(parsed.toolName)
+  ) {
     return {
       valid: false,
       error: 'Tool names must start with uppercase',
@@ -238,6 +244,12 @@ export function validatePermissionRule(rule: string): {
   return { valid: true }
 }
 
+function isUmmayaLowercaseToolName(toolName: string): boolean {
+  return /^(?:document(?:_[a-z0-9]+)*|workspace_[a-z0-9_]+|lookup|resolve_location|submit|verify|find|locate|send|check)$/u.test(
+    toolName,
+  )
+}
+
 /**
  * Custom Zod schema for permission rule arrays
  */

package/tui/src/utils/settings/types.ts

@@ -8,6 +8,7 @@ import {
   PERMISSION_MODES,
 } from '../permissions/PermissionMode.js'
 import { MarketplaceSourceSchema } from '../plugins/schemas.js'
+import { REASONING_MODES } from '../kExaoneReasoning.js'
 import { CLAUDE_CODE_SETTINGS_SCHEMA_URL } from './constants.js'
 import { PermissionRuleSchema } from './permissionValidation.js'
 
@@ -63,7 +64,7 @@ export const PermissionsSchema = lazySchema(() =>
             : EXTERNAL_PERMISSION_MODES,
         )
         .optional()
-        .describe('Default permission mode when Claude Code needs access'),
+        .describe('Default permission mode when UMMAYA needs access'),
       disableBypassPermissionsMode: z
         .enum(['disable'])
         .optional()
@@ -291,7 +292,7 @@ export const SettingsSchema = lazySchema(() =>
                   .describe('IdP issuer URL for OIDC discovery'),
                 clientId: z
                   .string()
-                  .describe("Claude Code's client_id registered at the IdP"),
+                  .describe("UMMAYA's client_id registered at the IdP"),
                 callbackPort: z
                   .number()
                   .int()
@@ -332,7 +333,7 @@ export const SettingsSchema = lazySchema(() =>
         ),
       env: EnvironmentVariablesSchema()
         .optional()
-        .describe('Environment variables to set for Claude Code sessions'),
+        .describe('Environment variables to set for UMMAYA sessions'),
       // Attribution for commits and PRs
       attribution: z
         .object({
@@ -709,6 +710,11 @@ export const SettingsSchema = lazySchema(() =>
         .optional()
         .catch(undefined)
         .describe('Persisted effort level for supported models.'),
+      reasoningMode: z
+        .enum(REASONING_MODES)
+        .optional()
+        .catch(undefined)
+        .describe('K-EXAONE/FriendliAI reasoning policy mode.'),
       advisorModel: z
         .string()
         .optional()

package/tui/src/utils/shell/prefix.ts

@@ -14,7 +14,7 @@ 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 { queryHaiku } from '../../services/api/ummaya.js'
 import { startsWithApiErrorPrefix } from '../../services/api/errors.js'
 import { memoizeWithLRU } from '../memoize.js'
 import { jsonStringify } from '../slowOperations.js'

package/tui/src/utils/sideQuery.ts

@@ -12,7 +12,7 @@ import {
 } from '../constants/system.js'
 import { logEvent } from '../services/analytics/index.js'
 import type { AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS } from '../services/analytics/metadata.js'
-import { getAPIMetadata } from '../services/api/claude.js'
+import { getAPIMetadata } from '../services/api/ummaya.js'
 import { getAnthropicClient } from '../services/api/client.js'
 import { getModelBetas, modelSupportsStructuredOutputs } from './betas.js'
 import { computeFingerprint } from './fingerprint.js'

package/tui/src/utils/stats.ts

@@ -634,7 +634,7 @@ function cacheToStats(
 }
 
 /**
- * Aggregates stats from all Claude Code sessions across all projects.
+ * Aggregates stats from all UMMAYA sessions across all projects.
  * Uses a disk cache to avoid reprocessing historical data.
  */
 export async function aggregateClaudeCodeStats(): Promise<ClaudeCodeStats> {

package/tui/src/utils/systemThemeWatcher.ts

@@ -4,6 +4,16 @@
 // CC consumer references (ThemeProvider.tsx:69) imply CC has runtime equivalents but they're
 // not in restored-src — UMMAYA NO-OP is justified until TUI Fidelity Meta-Epic
 // decides on UMMAYA-original implementation.
-const __stub: any = undefined
-export default __stub
-export {}
+import type { TerminalQuerier } from '../ink/terminal-querier.js'
+import type { SystemTheme } from './systemTheme.js'
+
+type ThemeChangeHandler = (theme: SystemTheme) => void
+
+export function watchSystemTheme(
+  _querier: TerminalQuerier,
+  _onThemeChange: ThemeChangeHandler,
+): () => void {
+  return () => {}
+}
+
+export default watchSystemTheme

package/tui/src/utils/teleport.tsx

@@ -12,7 +12,7 @@ import { getOauthConfig } from '../constants/oauth.js';
 import type { SDKMessage } from '../entrypoints/agentSdkTypes.js';
 import type { Root } from '../ink.js';
 import { KeybindingSetup } from '../keybindings/KeybindingProviderSetup.js';
-import { queryHaiku } from '../services/api/claude.js';
+import { queryHaiku } from '../services/api/ummaya.js';
 import { getSessionLogsViaOAuth, getTeleportEvents } from '../services/api/sessionIngress.js';
 import { getOrganizationUUID } from '../services/oauth/client.js';
 import { AppStateProvider } from '../state/AppState.js';