ummaya 0.2.4 → 0.2.5

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

@@ -0,0 +1,194 @@
+import { createHash, randomUUID } from 'node:crypto'
+import { appendFileSync, mkdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { getSessionId } from '../../../bootstrap/state.js'
+import {
+  appendRouteDiagnostic,
+  hashRouteDiagnosticText,
+} from '../../../tools/AdapterTool/routeDiagnostics.js'
+import { getUmmayaUserTierRoot } from '../../../utils/ummayaPaths.js'
+import { logForDebugging } from '../../../utils/debug.js'
+import { latestUserText } from './messages.js'
+import type { QueryModelParams } from './types.js'
+
+export type ProviderTurnEvidenceContext = {
+  readonly session_id: string
+  readonly correlation_id: string
+  readonly frame_hash: string
+  readonly query_hash: string
+  readonly query_source: string
+  readonly model: string
+}
+
+type ProviderTurnEvidenceEvent = 'provider_turn_start' | 'provider_turn_complete'
+
+type ProviderTurnEvidenceRecord = ProviderTurnEvidenceContext & {
+  readonly schema_version: 'ummaya.tui.turn_evidence.v1'
+  readonly ts: string
+  readonly event: ProviderTurnEvidenceEvent
+  readonly source: 'provider_direct'
+  readonly sanitized: true
+}
+
+export function createProviderTurnEvidenceContext(
+  params: QueryModelParams,
+): ProviderTurnEvidenceContext {
+  const sessionId = getSessionId()
+  const correlationId = randomUUID()
+  const queryHash = hashRouteDiagnosticText(latestUserText(params.messages))
+  const querySource = params.options.querySource
+  const model = params.options.model
+  return {
+    session_id: sessionId,
+    correlation_id: correlationId,
+    frame_hash: hashFrame({
+      sessionId,
+      correlationId,
+      queryHash,
+      querySource,
+      model,
+    }),
+    query_hash: queryHash,
+    query_source: querySource,
+    model,
+  }
+}
+
+export function appendProviderTurnEvidence(
+  event: ProviderTurnEvidenceEvent,
+  context: ProviderTurnEvidenceContext,
+): void {
+  appendRouteDiagnostic(event, {
+    session_id: context.session_id,
+    correlation_id: context.correlation_id,
+    frame_hash: context.frame_hash,
+    query_hash: context.query_hash,
+    query_source: context.query_source,
+    model: context.model,
+  })
+
+  const memdirFile = evidenceFilePath(context.session_id)
+  if (memdirFile === null) return
+  const record: ProviderTurnEvidenceRecord = {
+    schema_version: 'ummaya.tui.turn_evidence.v1',
+    ts: new Date().toISOString(),
+    event,
+    source: 'provider_direct',
+    sanitized: true,
+    ...context,
+  }
+  try {
+    mkdirSync(join(getUmmayaUserTierRoot(), 'evidence', 'tui-turns'), {
+      recursive: true,
+    })
+    appendFileSync(memdirFile, `${JSON.stringify(record)}\n`, {
+      encoding: 'utf8',
+      mode: 0o600,
+    })
+  } catch (error) {
+    if (error instanceof Error) {
+      logForDebugging(`provider turn evidence write failed: ${error.message}`)
+      return
+    }
+    throw error
+  }
+}
+
+export function appendProviderOutputEvidence(
+  event: unknown,
+  context: ProviderTurnEvidenceContext,
+): void {
+  const summary = providerOutputSummary(event)
+  appendRouteDiagnostic('provider_output', {
+    session_id: context.session_id,
+    correlation_id: context.correlation_id,
+    frame_hash: context.frame_hash,
+    query_hash: context.query_hash,
+    query_source: context.query_source,
+    model: context.model,
+    output_type: summary.outputType,
+    stream_event_type: summary.streamEventType,
+    assistant_text_chars: summary.assistantTextChars,
+    assistant_tool_use_count: summary.assistantToolUseCount,
+    assistant_content_block_count: summary.assistantContentBlockCount,
+    is_api_error_message: summary.isApiErrorMessage,
+  })
+}
+
+function evidenceFilePath(sessionId: string): string | null {
+  if (!process.env.UMMAYA_MEMDIR_USER) return null
+  return join(getUmmayaUserTierRoot(), 'evidence', 'tui-turns', `${sessionId}.jsonl`)
+}
+
+function providerOutputSummary(event: unknown): {
+  readonly outputType: string
+  readonly streamEventType: string | null
+  readonly assistantTextChars: number
+  readonly assistantToolUseCount: number
+  readonly assistantContentBlockCount: number
+  readonly isApiErrorMessage: boolean
+} {
+  if (!isRecord(event)) {
+    return emptyProviderOutputSummary('unknown')
+  }
+  const type = typeof event.type === 'string' ? event.type : 'unknown'
+  if (type === 'stream_event') {
+    const streamEvent = isRecord(event.event) ? event.event : {}
+    return {
+      ...emptyProviderOutputSummary(type),
+      streamEventType:
+        typeof streamEvent.type === 'string' ? streamEvent.type : null,
+    }
+  }
+  if (type !== 'assistant') {
+    return emptyProviderOutputSummary(type)
+  }
+  const message = isRecord(event.message) ? event.message : {}
+  const content = Array.isArray(message.content) ? message.content : []
+  let assistantTextChars = 0
+  let assistantToolUseCount = 0
+  for (const block of content) {
+    if (!isRecord(block)) continue
+    if (block.type === 'text' && typeof block.text === 'string') {
+      assistantTextChars += block.text.length
+    }
+    if (block.type === 'tool_use') {
+      assistantToolUseCount += 1
+    }
+  }
+  return {
+    outputType: type,
+    streamEventType: null,
+    assistantTextChars,
+    assistantToolUseCount,
+    assistantContentBlockCount: content.length,
+    isApiErrorMessage: event.isApiErrorMessage === true,
+  }
+}
+
+function emptyProviderOutputSummary(outputType: string) {
+  return {
+    outputType,
+    streamEventType: null,
+    assistantTextChars: 0,
+    assistantToolUseCount: 0,
+    assistantContentBlockCount: 0,
+    isApiErrorMessage: false,
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function hashFrame(payload: {
+  readonly sessionId: string
+  readonly correlationId: string
+  readonly queryHash: string
+  readonly querySource: string
+  readonly model: string
+}): string {
+  return createHash('sha256')
+    .update(JSON.stringify(payload), 'utf8')
+    .digest('hex')
+}

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

@@ -0,0 +1,255 @@
+import type { Message } from '../../../types/message.js'
+import type { SystemPrompt } from '../../../utils/systemPromptType.js'
+import type { OpenAIMessage, OpenAIToolCall } from './types.js'
+
+type CacheControl = {
+  readonly type: 'ephemeral'
+  readonly scope?: 'global' | 'org'
+  readonly ttl?: '5m' | '1h'
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function textFromContent(content: unknown): string {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  return content
+    .filter(isRecord)
+    .filter(block => block.type === 'text' && typeof block.text === 'string')
+    .map(block => String(block.text))
+    .join('')
+}
+
+type ToolUseBlock = {
+  readonly type: 'tool_use'
+  readonly id: string
+  readonly name: string
+  readonly input?: unknown
+}
+
+type ToolResultBlock = {
+  readonly type: 'tool_result'
+  readonly tool_use_id: string
+  readonly content?: unknown
+}
+
+function asToolUseBlock(value: unknown): ToolUseBlock | undefined {
+  if (!isRecord(value)) return undefined
+  if (value.type !== 'tool_use') return undefined
+  if (typeof value.id !== 'string' || value.id.length === 0) return undefined
+  if (typeof value.name !== 'string' || value.name.length === 0) return undefined
+  return {
+    type: 'tool_use',
+    id: value.id,
+    name: value.name,
+    input: value.input,
+  }
+}
+
+function asToolResultBlock(value: unknown): ToolResultBlock | undefined {
+  if (!isRecord(value)) return undefined
+  if (value.type !== 'tool_result') return undefined
+  if (typeof value.tool_use_id !== 'string' || value.tool_use_id.length === 0) {
+    return undefined
+  }
+  return {
+    type: 'tool_result',
+    tool_use_id: value.tool_use_id,
+    content: value.content,
+  }
+}
+
+function serializeToolUseInput(input: unknown): string {
+  if (typeof input === 'string') return input
+  if (input === undefined || input === null) return '{}'
+  try {
+    return JSON.stringify(input)
+  } catch {
+    return '{}'
+  }
+}
+
+function serializeToolResultContent(content: unknown): string {
+  if (typeof content === 'string') return content
+  if (content === undefined || content === null) return ''
+  try {
+    return JSON.stringify(content)
+  } catch {
+    return String(content)
+  }
+}
+
+function findToolNameForResult(
+  toolUseId: string,
+  emittedMessages: readonly OpenAIMessage[],
+): string | undefined {
+  for (let index = emittedMessages.length - 1; index >= 0; index -= 1) {
+    const message = emittedMessages[index]
+    if (message?.role !== 'assistant') continue
+    for (const toolCall of message.tool_calls ?? []) {
+      if (toolCall.id === toolUseId) return toolCall.function.name
+    }
+  }
+  return undefined
+}
+
+function collectToolResultIds(messages: readonly Message[]): ReadonlySet<string> {
+  const toolResultIds = new Set<string>()
+  for (const message of messages) {
+    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) toolResultIds.add(toolResult.tool_use_id)
+    }
+  }
+  return toolResultIds
+}
+
+function transcriptMessageToOpenAIMessages(
+  message: Message,
+  emittedMessages: readonly OpenAIMessage[],
+  matchedToolResultIds: ReadonlySet<string>,
+): readonly OpenAIMessage[] {
+  if (message.type !== 'user' && message.type !== 'assistant') return []
+  const content = message.message.content
+  if (typeof content === 'string') {
+    return content.length > 0 ? [{ role: message.type, content }] : []
+  }
+  if (!Array.isArray(content)) return []
+
+  if (message.type === 'user') {
+    const out: OpenAIMessage[] = []
+    const textContent = textFromContent(content)
+    for (const block of content) {
+      const toolResult = asToolResultBlock(block)
+      if (toolResult === undefined) continue
+      const toolName = findToolNameForResult(toolResult.tool_use_id, emittedMessages)
+      if (toolName === undefined) continue
+      out.push({
+        role: 'tool',
+        name: toolName,
+        tool_call_id: toolResult.tool_use_id,
+        content: serializeToolResultContent(toolResult.content),
+      })
+    }
+    if (textContent.length > 0) {
+      out.push({ role: 'user', content: textContent })
+    }
+    return out
+  }
+
+  const toolCalls: OpenAIToolCall[] = []
+  for (const block of content) {
+    const toolUse = asToolUseBlock(block)
+    if (toolUse === undefined) continue
+    if (!matchedToolResultIds.has(toolUse.id)) continue
+    toolCalls.push({
+      id: toolUse.id,
+      type: 'function',
+      function: {
+        name: toolUse.name,
+        arguments: serializeToolUseInput(toolUse.input),
+      },
+    })
+  }
+
+  const textContent = textFromContent(content)
+  if (toolCalls.length > 0) {
+    return [{ role: 'assistant', content: textContent, tool_calls: toolCalls }]
+  }
+  return textContent.length > 0 ? [{ role: 'assistant', content: textContent }] : []
+}
+
+export function systemPromptText(systemPrompt: SystemPrompt): string {
+  return Array.from(systemPrompt).join('\n')
+}
+
+export function latestUserText(messages: readonly Message[]): string {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index]
+    if (message?.type === 'user' && message.isMeta !== true) {
+      const text = textFromContent(message.message.content).trim()
+      if (text.length > 0) return text
+    }
+  }
+  return ''
+}
+
+export function transcriptToOpenAIMessages(
+  messages: readonly Message[],
+  systemPrompt: SystemPrompt,
+  extraSystemInstruction?: string,
+): readonly OpenAIMessage[] {
+  const out: OpenAIMessage[] = [
+    {
+      role: 'system',
+      content: [systemPromptText(systemPrompt), extraSystemInstruction]
+        .filter(Boolean)
+        .join('\n\n'),
+    },
+  ]
+  const matchedToolResultIds = collectToolResultIds(messages)
+  for (const message of messages) {
+    out.push(...transcriptMessageToOpenAIMessages(message, out, matchedToolResultIds))
+  }
+  return out
+}
+
+export function getPromptCachingEnabled(_model: string): boolean {
+  return false
+}
+
+export function getCacheControl(
+  _params: { readonly scope?: 'global' | 'org'; readonly querySource?: string } = {},
+): CacheControl {
+  return { type: 'ephemeral' }
+}
+
+export function userMessageToMessageParam(
+  message: Message,
+  _addCache = false,
+  _enablePromptCaching = false,
+  _querySource?: string,
+): OpenAIMessage {
+  return { role: 'user', content: textFromContent(message.message.content) }
+}
+
+export function assistantMessageToMessageParam(
+  message: Message,
+  _addCache = false,
+  _enablePromptCaching = false,
+  _querySource?: string,
+): OpenAIMessage {
+  return { role: 'assistant', content: textFromContent(message.message.content) }
+}
+
+export function stripExcessMediaItems<T>(
+  messages: readonly T[],
+  _limit: number,
+): readonly T[] {
+  return messages
+}
+
+export function addCacheBreakpoints<T>(
+  messages: readonly T[],
+  _enablePromptCaching: boolean,
+  _querySource?: string,
+  _useCachedMC = false,
+  _newCacheEdits?: unknown,
+  _pinnedEdits?: unknown,
+  _skipCacheWrite = false,
+): readonly T[] {
+  return messages
+}
+
+export function buildSystemPromptBlocks(
+  systemPrompt: SystemPrompt,
+  _enablePromptCaching: boolean,
+  _options?: unknown,
+): readonly { readonly text: string }[] {
+  return [{ text: systemPromptText(systemPrompt) }]
+}

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

@@ -0,0 +1,66 @@
+import { createAssistantMessage } from '../../../utils/messages.js'
+import { createUserMessage } from '../../../utils/userMessageFactories.js'
+import { asSystemPrompt } from '../../../utils/systemPromptType.js'
+import { EMPTY_USAGE } from './types.js'
+import type { QueryModelParams } from './types.js'
+
+export const MAX_NON_STREAMING_TOKENS = 64_000
+
+export function adjustParamsForNonStreaming<T>(
+  params: T,
+  _maxTokensCap: number,
+): T {
+  return params
+}
+
+export async function* executeNonStreamingRequest(
+  _clientOptions: unknown,
+  _retryOptions: unknown,
+  _paramsFromContext: unknown,
+  _onAttempt?: unknown,
+  _captureRequest?: unknown,
+): AsyncGenerator<unknown> {
+  yield createAssistantMessage({ content: '' })
+}
+
+export async function queryModelWithoutStreaming(
+  params: QueryModelParams,
+): Promise<unknown> {
+  const events: unknown[] = []
+  const { queryModelWithStreaming } = await import('./provider.js')
+  for await (const event of queryModelWithStreaming(params)) {
+    events.push(event)
+  }
+  return events.find(
+    event =>
+      typeof event === 'object' &&
+      event !== null &&
+      'type' in event &&
+      event.type === 'assistant',
+  )
+}
+
+export async function queryHaiku(params: {
+  readonly systemPrompt?: ReturnType<typeof asSystemPrompt>
+  readonly userPrompt: string
+  readonly outputFormat?: unknown
+  readonly signal?: AbortSignal
+  readonly options: QueryModelParams['options']
+}): Promise<unknown> {
+  return queryModelWithoutStreaming({
+    messages: [createUserMessage({ content: params.userPrompt })],
+    systemPrompt: params.systemPrompt ?? asSystemPrompt([]),
+    thinkingConfig: { type: 'disabled' },
+    tools: [],
+    signal: params.signal ?? new AbortController().signal,
+    options: params.options,
+  })
+}
+
+export async function queryWithModel(params: Parameters<typeof queryHaiku>[0]): Promise<unknown> {
+  return queryHaiku(params)
+}
+
+export function getMaxOutputTokensForModel(_model: string): number {
+  return EMPTY_USAGE.output_tokens + MAX_NON_STREAMING_TOKENS
+}