ummaya 0.2.4 → 0.2.5

package/tui/src/services/api/ummaya/provider.ts

@@ -0,0 +1,200 @@
+import { assertFriendliApiKeyForUse } from '../../../utils/auth.js'
+import {
+  createAssistantAPIErrorMessage,
+  createAssistantMessage,
+} from '../../../utils/messages.js'
+import { ensureUmmayaAdapterManifest } from '../../../ipc/bridgeSingleton.js'
+import { latestUserText } from './messages.js'
+import { buildProviderRequest, getAPIMetadata } from './request.js'
+import {
+  ProviderStreamIdleTimeoutError,
+  streamResponseToMessages,
+} from './streaming.js'
+import { shouldWaitForAdapterManifestForProviderRequest } from './toolSelection.js'
+import type { QueryModelParams } from './types.js'
+import {
+  appendProviderOutputEvidence,
+  appendProviderTurnEvidence,
+  createProviderTurnEvidenceContext,
+} from './evidence.js'
+import type { ProviderOptions } from './types.js'
+
+export { getAPIMetadata }
+
+export const PUBLIC_SERVICE_MANIFEST_SYNC_TIMEOUT_MS = 30_000
+const PROVIDER_STREAM_TIMEOUT_HANDOFF =
+  'K-EXAONE 응답이 지연되어 이번 요청을 이어갈 수 없습니다. 잠시 후 다시 시도해 주세요.'
+const DEFAULT_PROVIDER_EVENT_IDLE_TIMEOUT_MS = 90_000
+const PROVIDER_EVENT_IDLE_TIMEOUT_ENV = 'UMMAYA_TUI_PROVIDER_EVENT_IDLE_TIMEOUT_MS'
+const FRAME_IDLE_TIMEOUT_ENV = 'UMMAYA_TUI_FRAME_IDLE_TIMEOUT_MS'
+const FRIENDLI_CHAT_COMPLETIONS_URL =
+  'https://api.friendli.ai/serverless/v1/chat/completions'
+const TEST_PUBLIC_SERVICE_MANIFEST_SYNC_TIMEOUT_ENV =
+  'UMMAYA_TEST_PUBLIC_SERVICE_MANIFEST_SYNC_TIMEOUT_MS'
+
+function publicServiceManifestSyncTimeoutMs(): number {
+  const rawTimeout = process.env[TEST_PUBLIC_SERVICE_MANIFEST_SYNC_TIMEOUT_ENV]
+  if (rawTimeout === undefined) return PUBLIC_SERVICE_MANIFEST_SYNC_TIMEOUT_MS
+
+  const parsedTimeout = Number(rawTimeout)
+  if (!Number.isInteger(parsedTimeout) || parsedTimeout <= 0) {
+    return PUBLIC_SERVICE_MANIFEST_SYNC_TIMEOUT_MS
+  }
+  return parsedTimeout
+}
+
+function adapterManifestTimeoutMessage(timeoutMs: number): string {
+  return [
+    `public-service adapter manifest did not sync within ${timeoutMs}ms;`,
+    'backend readiness is required before starting public-service provider requests.',
+    'Retry after adapter_manifest_sync arrives from the backend.',
+  ].join(' ')
+}
+
+function providerEventIdleTimeoutMs(): number {
+  const rawTimeout =
+    process.env[PROVIDER_EVENT_IDLE_TIMEOUT_ENV] ??
+    process.env[FRAME_IDLE_TIMEOUT_ENV]
+  if (rawTimeout === undefined) return DEFAULT_PROVIDER_EVENT_IDLE_TIMEOUT_MS
+
+  const parsedTimeout = Number.parseInt(rawTimeout, 10)
+  if (!Number.isFinite(parsedTimeout) || parsedTimeout <= 0) {
+    return DEFAULT_PROVIDER_EVENT_IDLE_TIMEOUT_MS
+  }
+  return parsedTimeout
+}
+
+export function getExtraBodyParams(_betaHeaders?: readonly string[]): Record<string, unknown> {
+  return {}
+}
+
+export function configureTaskBudgetParams(
+  taskBudget: { readonly total: number; readonly remaining?: number } | undefined,
+  outputConfig: Record<string, unknown>,
+  _betas: string[],
+): void {
+  if (!taskBudget) return
+  outputConfig.task_budget = taskBudget
+}
+
+export async function verifyApiKey(
+  apiKey: string,
+  _isNonInteractiveSession: boolean,
+): Promise<boolean> {
+  return apiKey.trim().length > 0
+}
+
+export async function* queryModelWithStreaming(
+  params: QueryModelParams,
+): AsyncGenerator<unknown> {
+  assertFriendliApiKeyForUse()
+  const evidenceContext = createProviderTurnEvidenceContext(params)
+  const userText = latestUserText(params.messages)
+  if (
+    shouldWaitForAdapterManifestForProviderRequest({
+      querySource: params.options.querySource,
+      userText,
+    })
+  ) {
+    const timeoutMs = publicServiceManifestSyncTimeoutMs()
+    const manifestSynced = await ensureUmmayaAdapterManifest(timeoutMs)
+    if (!manifestSynced) {
+      yield createAssistantAPIErrorMessage({
+        content: adapterManifestTimeoutMessage(timeoutMs),
+        apiError: 'api_error',
+      })
+      return
+    }
+  }
+  const request = buildProviderRequest(params, evidenceContext)
+  const fetchImpl: NonNullable<ProviderOptions['fetchOverride']> =
+    params.options.fetchOverride ?? ((input, init) => fetch(input, init))
+  yield { type: 'stream_request_start' as const }
+  let providerTurnStarted = false
+  try {
+    appendProviderTurnEvidence('provider_turn_start', evidenceContext)
+    providerTurnStarted = true
+    const response = await fetchProviderResponse(
+      fetchImpl,
+      {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+          authorization: `Bearer ${process.env.UMMAYA_FRIENDLI_TOKEN ?? ''}`,
+        },
+        body: JSON.stringify(request),
+        signal: params.signal,
+      },
+      providerEventIdleTimeoutMs(),
+    )
+    for await (const event of streamResponseToMessages(response, {
+      dataIdleTimeoutMs: providerEventIdleTimeoutMs(),
+      availableToolNames: rawJsonToolCallNamesForRequest(request),
+      includeReasoning: request.include_reasoning === true,
+    })) {
+      appendProviderOutputEvidence(event, evidenceContext)
+      yield event
+    }
+  } catch (error) {
+    if (error instanceof ProviderStreamIdleTimeoutError) {
+      yield createAssistantMessage({
+        content: PROVIDER_STREAM_TIMEOUT_HANDOFF,
+      })
+      return
+    }
+    throw error
+  } finally {
+    if (providerTurnStarted) {
+      appendProviderTurnEvidence('provider_turn_complete', evidenceContext)
+    }
+  }
+}
+
+function rawJsonToolCallNamesForRequest(request: {
+  readonly tools?: readonly {
+    readonly function: { readonly name: string }
+  }[]
+}): readonly string[] {
+  const names = new Set<string>()
+  for (const tool of request.tools ?? []) {
+    const name = tool.function.name.trim()
+    if (name.length > 0) names.add(name)
+  }
+  return [...names]
+}
+
+async function fetchProviderResponse(
+  fetchImpl: NonNullable<ProviderOptions['fetchOverride']>,
+  init: RequestInit,
+  timeoutMs: number,
+): Promise<Response> {
+  const controller = new AbortController()
+  const upstreamSignal = init.signal
+  const abortFromUpstream = () => {
+    controller.abort(upstreamSignal?.reason)
+  }
+  if (upstreamSignal?.aborted) {
+    controller.abort(upstreamSignal.reason)
+  } else {
+    upstreamSignal?.addEventListener('abort', abortFromUpstream, { once: true })
+  }
+  let timeoutId: ReturnType<typeof setTimeout> | undefined
+  const timeout = new Promise<never>((_, reject) => {
+    timeoutId = setTimeout(() => {
+      controller.abort()
+      reject(new ProviderStreamIdleTimeoutError(timeoutMs))
+    }, timeoutMs)
+  })
+  try {
+    return await Promise.race([
+      fetchImpl(FRIENDLI_CHAT_COMPLETIONS_URL, {
+        ...init,
+        signal: controller.signal,
+      }),
+      timeout,
+    ])
+  } finally {
+    if (timeoutId !== undefined) clearTimeout(timeoutId)
+    upstreamSignal?.removeEventListener('abort', abortFromUpstream)
+  }
+}

package/tui/src/services/api/ummaya/reasoning.ts

@@ -0,0 +1,24 @@
+import {
+  getInitialReasoningModeSetting,
+  providerReasoningPayload,
+  resolveKExaoneReasoningPolicy,
+} from '../../../utils/kExaoneReasoning.js'
+
+export function providerReasoningRequestPayload(): {
+  readonly chat_template_kwargs: { readonly enable_thinking: boolean }
+  readonly parse_reasoning: boolean
+  readonly include_reasoning: boolean
+} {
+  const envResolvedPolicy = resolveKExaoneReasoningPolicy()
+  if (
+    envResolvedPolicy.source === 'env' ||
+    envResolvedPolicy.source === 'legacy-env'
+  ) {
+    return providerReasoningPayload(envResolvedPolicy)
+  }
+  return providerReasoningPayload(
+    resolveKExaoneReasoningPolicy({
+      userSettingsMode: getInitialReasoningModeSetting(),
+    }),
+  )
+}

package/tui/src/services/api/ummaya/request.ts

@@ -0,0 +1,200 @@
+import { z } from 'zod/v4'
+import type { Tool } from '../../../Tool.js'
+import type {
+  OpenAITool,
+  ProviderOptions,
+  ProviderRequest,
+  QueryModelParams,
+} from './types.js'
+import { latestUserText, transcriptToOpenAIMessages } from './messages.js'
+import {
+  selectProviderToolChoiceName,
+  selectProviderTools,
+} from './toolSelection.js'
+import type { ProviderTurnEvidenceContext } from './evidence.js'
+import {
+  hasCurrentTurnLocationContext,
+  selectionTextWithPriorLocationContext,
+} from './selectionContext.js'
+import { providerReasoningRequestPayload } from './reasoning.js'
+
+function forcedToolChoiceSystemInstruction(toolName: string): string {
+  if (toolName === 'workspace_bash') {
+    return [
+      `Mandatory tool call: the host selected ${toolName} for this turn.`,
+      'Do not answer with prose, do not ask a follow-up question, and do not choose another tool.',
+      `Emit exactly one ${toolName} tool call with valid JSON arguments.`,
+      'For sequenced shell requests, emit the next concrete shell command requested by the user rather than a status summary.',
+      'If the user asks to attempt a destructive command and says they will deny the permission prompt, still emit that destructive command so the host permission gate can prompt and enforce the denial.',
+      'Do not replace a requested delete command with ls/find/path-existence prose, and preserve leading dots in hidden paths such as .omo/...',
+    ].join(' ')
+  }
+  return `Mandatory tool call: the host selected ${toolName} for this turn. Do not answer with prose, do not ask a follow-up question, and do not choose another tool. Emit exactly one ${toolName} tool call with valid JSON arguments.`
+}
+
+function schemaForTool(tool: Tool): Record<string, unknown> {
+  if (tool.inputJSONSchema) {
+    return normalizeProviderParameterSchema(tool.inputJSONSchema)
+  }
+  const generatedSchema = z.toJSONSchema(tool.inputSchema)
+  return normalizeProviderParameterSchema(
+    isJsonObject(generatedSchema) ? generatedSchema : {},
+  )
+}
+
+function normalizeProviderParameterSchema(
+  schema: Record<string, unknown>,
+): Record<string, unknown> {
+  const normalized = normalizeSchemaNode(schema, schema, new Set<string>())
+  if (isJsonObject(normalized)) return normalized
+  return providerSafeUnresolvedRefSchema()
+}
+
+function normalizeSchemaNode(
+  value: unknown,
+  root: Record<string, unknown>,
+  refStack: ReadonlySet<string>,
+): unknown {
+  if (Array.isArray(value)) {
+    return value.map(item => normalizeSchemaNode(item, root, refStack))
+  }
+  if (!isJsonObject(value)) return value
+
+  const ref = typeof value.$ref === 'string' ? value.$ref : undefined
+  if (ref !== undefined) {
+    const inlined = inlineLocalSchemaRef(ref, value, root, refStack)
+    if (inlined !== undefined) return inlined
+    return providerSafeUnresolvedRefSchema()
+  }
+
+  const normalized: Record<string, unknown> = {}
+  for (const [key, child] of Object.entries(value)) {
+    if (key === '$defs' || key === 'definitions') continue
+    normalized[key] = normalizeSchemaNode(child, root, refStack)
+  }
+  return normalized
+}
+
+function inlineLocalSchemaRef(
+  ref: string,
+  schemaWithRef: Record<string, unknown>,
+  root: Record<string, unknown>,
+  refStack: ReadonlySet<string>,
+): unknown | undefined {
+  if (refStack.has(ref)) return undefined
+  const resolved = resolveLocalSchemaRef(root, ref)
+  if (resolved === undefined) return undefined
+  const nextStack = new Set(refStack)
+  nextStack.add(ref)
+  const normalizedResolved = normalizeSchemaNode(resolved, root, nextStack)
+  if (!isJsonObject(normalizedResolved)) return normalizedResolved
+
+  const normalizedSiblings: Record<string, unknown> = {}
+  for (const [key, child] of Object.entries(schemaWithRef)) {
+    if (key === '$ref' || key === '$defs' || key === 'definitions') continue
+    normalizedSiblings[key] = normalizeSchemaNode(child, root, nextStack)
+  }
+  return {
+    ...normalizedResolved,
+    ...normalizedSiblings,
+  }
+}
+
+function resolveLocalSchemaRef(
+  root: Record<string, unknown>,
+  ref: string,
+): unknown | undefined {
+  if (ref === '#') return root
+  if (!ref.startsWith('#/')) return undefined
+
+  let current: unknown = root
+  for (const segment of ref.slice(2).split('/').map(decodeJsonPointerSegment)) {
+    if (!isJsonObject(current)) return undefined
+    current = current[segment]
+  }
+  return current
+}
+
+function decodeJsonPointerSegment(segment: string): string {
+  return segment.replace(/~1/g, '/').replace(/~0/g, '~')
+}
+
+function providerSafeUnresolvedRefSchema(): Record<string, unknown> {
+  return {
+    type: 'object',
+    description:
+      'Provider-safe open object for an unresolved local schema reference.',
+    properties: {},
+    additionalProperties: true,
+  }
+}
+
+function isJsonObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function toolToOpenAI(tool: Tool): OpenAITool {
+  return {
+    type: 'function',
+    function: {
+      name: tool.name,
+      description: tool.searchHint ?? tool.name,
+      parameters: schemaForTool(tool),
+    },
+  }
+}
+
+function toolChoiceFor(
+  toolName: string | undefined,
+): ProviderRequest['tool_choice'] {
+  if (toolName === undefined) return undefined
+  return {
+    type: 'function',
+    function: { name: toolName },
+  }
+}
+
+export function buildProviderRequest(
+  params: QueryModelParams,
+  evidenceContext?: ProviderTurnEvidenceContext,
+): ProviderRequest {
+  const forcedToolName =
+    params.options.toolChoice?.type === 'tool'
+      ? params.options.toolChoice.name
+      : undefined
+  const userText = selectionTextWithPriorLocationContext(params.messages)
+  const selectedToolChoiceName = selectProviderToolChoiceName({
+    tools: params.tools,
+    userText,
+    forcedToolName,
+  })
+  const tools = selectProviderTools({
+    tools: params.tools,
+    userText,
+    forcedToolName: selectedToolChoiceName,
+    disabledToolNames: params.options.disabledProviderToolNames ?? [],
+    querySource: params.options.querySource,
+    hasCurrentTurnLocationContext: hasCurrentTurnLocationContext(params.messages),
+    evidenceContext,
+  })
+  const toolChoice = toolChoiceFor(selectedToolChoiceName)
+  const toolPayload = tools.map(toolToOpenAI)
+  return {
+    model: params.options.model,
+    stream: true,
+    ...providerReasoningRequestPayload(),
+    messages: transcriptToOpenAIMessages(
+      params.messages,
+      params.systemPrompt,
+      selectedToolChoiceName
+        ? forcedToolChoiceSystemInstruction(selectedToolChoiceName)
+        : undefined,
+    ),
+    ...(toolPayload.length > 0 ? { tools: toolPayload } : {}),
+    ...(toolChoice ? { tool_choice: toolChoice } : {}),
+  }
+}
+
+export function getAPIMetadata(): Record<string, string> {
+  return { user_id: 'ummaya-local' }
+}

package/tui/src/services/api/ummaya/selectionContext.ts

@@ -0,0 +1,240 @@
+import type { Message } from '../../../types/message.js'
+import { latestUserText } from './messages.js'
+
+const RELATIVE_LOCATION_PROMPT_RE =
+  /(주위|주변|인근|가까운|우리\s*동네|여기|이\s*근처|현재\s*위치|내\s*위치)/iu
+const RELATIVE_HEALTH_PROMPT_RE =
+  /(응급|응급실|응급의료|병원|의원|진료|야간진료|약국|의료|건강|아파|다쳤|발열|hospital|clinic|pharmacy|emergency|ER)/iu
+
+type ToolResultBlock = {
+  readonly type: 'tool_result'
+  readonly content?: unknown
+  readonly isError: boolean
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function asToolResultBlock(value: unknown): ToolResultBlock | undefined {
+  if (!isRecord(value)) return undefined
+  if (value.type !== 'tool_result') return undefined
+  return {
+    type: 'tool_result',
+    content: value.content,
+    isError: value.is_error === true,
+  }
+}
+
+function parseJsonObject(value: unknown): Record<string, unknown> | undefined {
+  if (isRecord(value)) return value
+  if (typeof value !== 'string' || !value.trim()) return undefined
+  try {
+    const parsed: unknown = JSON.parse(value)
+    return isRecord(parsed) ? parsed : undefined
+  } catch {
+    return undefined
+  }
+}
+
+function textField(
+  source: Record<string, unknown>,
+  fieldName: string,
+): string | undefined {
+  const value = source[fieldName]
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined
+}
+
+function numberField(
+  source: Record<string, unknown>,
+  fieldName: string,
+): string | undefined {
+  const value = source[fieldName]
+  return typeof value === 'number' && Number.isFinite(value) ? String(value) : undefined
+}
+
+function fieldIndicatesFailure(value: unknown): boolean {
+  if (value === false) return true
+  if (typeof value !== 'string') return false
+  return /(error|fail|failed|failure|timeout|denied|unavailable|invalid)/iu.test(
+    value.trim(),
+  )
+}
+
+function hasExplicitFailure(source: Record<string, unknown>): boolean {
+  if (fieldIndicatesFailure(source.ok)) return true
+  if (fieldIndicatesFailure(source.success)) return true
+  if (fieldIndicatesFailure(source.status)) return true
+  const error = source.error
+  if (typeof error === 'string') return error.trim().length > 0
+  return error !== undefined && error !== null && error !== false
+}
+
+function payloadHasExplicitFailure(payload: Record<string, unknown>): boolean {
+  if (hasExplicitFailure(payload)) return true
+  const data = recordField(payload, 'data')
+  return data !== undefined && hasExplicitFailure(data)
+}
+
+function recordField(
+  source: Record<string, unknown>,
+  fieldName: string,
+): Record<string, unknown> | undefined {
+  const value = source[fieldName]
+  return isRecord(value) ? value : undefined
+}
+
+function firstTextField(
+  sources: readonly Record<string, unknown>[],
+  fieldNames: readonly string[],
+): string | undefined {
+  for (const source of sources) {
+    for (const fieldName of fieldNames) {
+      const value = textField(source, fieldName)
+      if (value !== undefined) return value
+    }
+  }
+  return undefined
+}
+
+function firstNumberField(
+  sources: readonly Record<string, unknown>[],
+  fieldNames: readonly string[],
+): string | undefined {
+  for (const source of sources) {
+    for (const fieldName of fieldNames) {
+      const value = numberField(source, fieldName)
+      if (value !== undefined) return value
+    }
+  }
+  return undefined
+}
+
+function locationCandidateRecords(
+  result: Record<string, unknown>,
+): readonly Record<string, unknown>[] {
+  const candidates = [result]
+  for (const slot of ['coords', 'poi', 'region', 'address', 'adm_cd'] as const) {
+    const nested = recordField(result, slot)
+    if (nested !== undefined) candidates.push(nested)
+  }
+  return candidates
+}
+
+function locationContextFromPayload(
+  payload: Record<string, unknown>,
+): string | undefined {
+  if (payloadHasExplicitFailure(payload)) return undefined
+  const data = isRecord(payload.data) ? payload.data : undefined
+  const result = isRecord(payload.result)
+    ? payload.result
+    : data !== undefined && isRecord(data.result)
+      ? data.result
+      : data ?? payload
+  const candidates = locationCandidateRecords(result)
+  const latitude = firstNumberField(candidates, ['lat', 'latitude'])
+  const longitude = firstNumberField(candidates, ['lon', 'longitude'])
+  const x =
+    firstTextField(candidates, ['x']) ??
+    firstNumberField(candidates, ['x', 'nx'])
+  const y =
+    firstTextField(candidates, ['y']) ??
+    firstNumberField(candidates, ['y', 'ny'])
+  const regionName =
+    firstTextField(candidates, ['rdd_da_name', 'address_name', 'name']) ??
+    [
+      firstTextField(candidates, ['region_1depth_name']),
+      firstTextField(candidates, ['region_2depth_name']),
+      firstTextField(candidates, ['region_3depth_name']),
+    ]
+      .filter(Boolean)
+      .join(' ')
+      .trim()
+  const address =
+    firstTextField(candidates, ['road_address', 'jibun_address'])
+  if (!latitude && !longitude && !x && !y && !regionName && !address) {
+    return undefined
+  }
+  return [
+    '[prior_location_context]',
+    regionName ? `region=${regionName}` : undefined,
+    address ? `address=${address}` : undefined,
+    latitude && longitude ? `lat=${latitude} lon=${longitude}` : undefined,
+    x && y ? `x=${x} y=${y}` : undefined,
+  ]
+    .filter(Boolean)
+    .join(' ')
+}
+
+function latestPriorLocationContext(messages: readonly Message[]): string | undefined {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index]
+    if (message?.type !== 'user') continue
+    const content = message.message.content
+    if (!Array.isArray(content)) continue
+    for (const block of content) {
+      const toolResult = asToolResultBlock(block)
+      if (toolResult === undefined) continue
+      if (toolResult.isError) continue
+      const parsed = parseJsonObject(toolResult.content)
+      if (parsed === undefined) continue
+      const context = locationContextFromPayload(parsed)
+      if (context !== undefined) return context
+    }
+  }
+  return undefined
+}
+
+function userTextForSelectionIndex(message: Message): string {
+  const content = message.message.content
+  if (typeof content === 'string') return content.trim()
+  if (!Array.isArray(content)) return ''
+  return content
+    .filter(isRecord)
+    .filter(block => block.type === 'text' && typeof block.text === 'string')
+    .map(block => String(block.text))
+    .join('')
+    .trim()
+}
+
+function latestCitizenTextIndex(messages: readonly Message[]): number {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index]
+    if (message?.type !== 'user' || message.isMeta === true) continue
+    if (userTextForSelectionIndex(message).length > 0) return index
+  }
+  return -1
+}
+
+export function hasCurrentTurnLocationContext(
+  messages: readonly Message[],
+): boolean {
+  const latestIndex = latestCitizenTextIndex(messages)
+  if (latestIndex < 0) return false
+  for (let index = latestIndex + 1; index < messages.length; index += 1) {
+    const message = messages[index]
+    if (message?.type !== 'user') continue
+    const content = message.message.content
+    if (!Array.isArray(content)) continue
+    for (const block of content) {
+      const toolResult = asToolResultBlock(block)
+      if (toolResult === undefined) continue
+      if (toolResult.isError) continue
+      const parsed = parseJsonObject(toolResult.content)
+      if (parsed !== undefined && locationContextFromPayload(parsed) !== undefined) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+export function selectionTextWithPriorLocationContext(
+  messages: readonly Message[],
+): string {
+  const latest = latestUserText(messages)
+  if (!RELATIVE_LOCATION_PROMPT_RE.test(latest)) return latest
+  if (!RELATIVE_HEALTH_PROMPT_RE.test(latest)) return latest
+  const locationContext = latestPriorLocationContext(messages)
+  return locationContext === undefined ? latest : `${latest}\n${locationContext}`
+}