ummaya 0.2.3 → 0.2.5

package/tui/src/ipc/llmClient.ts

@@ -18,7 +18,7 @@ import { trace, SpanStatusCode } from '@opentelemetry/api'
 import type { Span } from '@opentelemetry/api'
 import type { IPCBridge } from './bridge.js'
 import { makeUUIDv7, makeBaseEnvelope } from './envelope.js'
-import type { AssistantChunkFrame, BackpressureSignalFrame, ChatMessage as IPCChatMessage, ChatRequestFrame, ErrorFrame, ToolCallFrame, ToolResultFrame, ToolDefinition as IPCToolDefinition } from './frames.generated.js'
+import type { AssistantChunkFrame, BackpressureSignalFrame, ChatMessage as IPCChatMessage, ChatRequestFrame, ErrorFrame, ProgressEventFrame, ToolCallFrame, ToolResultFrame, ToolDefinition as IPCToolDefinition } from './frames.generated.js'
 import type { PendingCallRegistry } from '../tools/_shared/pendingCallRegistry.js'
 import { getOrCreatePendingCallRegistry } from './pendingCallSingleton.js'
 import type {
@@ -29,8 +29,13 @@ import type {
   UmmayaContentBlockParam,
   UmmayaStopReason,
 } from './llmTypes.js'
+import {
+  extractTextualToolCallProposals,
+  parseTrailingRawJsonToolCallProposal,
+} from '../utils/rawJsonToolCall.js'
 
 export const UMMAYA_DEFAULT_MODEL = 'LGAI-EXAONE/K-EXAONE-236B-A23B'
+const TEXTUAL_TOOL_CALL_OPEN = '<tool_call>'
 
 export type LLMClientErrorClass = 'llm' | 'tool' | 'network'
 
@@ -78,11 +83,13 @@ const _tracer = trace.getTracer('ummaya.tui.llm', '0.1.0')
 interface _TurnAccumulator {
   messageId: string | null
   contentBlocks: UmmayaContentBlockParam[]
+  accumulatedText: string
+  emittedTextLength: number
+  shouldBufferTextDeltas: boolean
   usage: UmmayaUsage
   stopReason: UmmayaStopReason
-  /** Index of the single text block. UMMAYA streams text into one block per
-   *  turn, so this stays at 0 and is the target of every `content_block_delta`
-   *  and the final `content_block_stop` for text. */
+  /** Index of the current text block. It is opened lazily on the first
+   *  CC-compatible text delta, not at message_start. */
   blockIndex: number
   /** Monotonic counter for tool_use blocks within this turn. The nth
    *  tool_use block lands at index `blockIndex + n` (so text is 0, tool
@@ -94,9 +101,11 @@ interface _TurnAccumulator {
    *  channel is forwarded by the backend as `AssistantChunkFrame.thinking`;
    *  llmClient mirrors CC's claude.ts:2148-2165 by routing those chunks to
    *  a dedicated thinking content block (`type: 'thinking'`). The block
-   *  is opened lazily on the first thinking delta and closed at the same
-   *  time as the text block (done frame). Undefined until first delta. */
+   *  is opened lazily on the first thinking delta and closed before text/tool
+   *  blocks, matching CC's one-open-content-block stream shape. */
   thinkingBlockIndex: number | undefined
+  /** Currently open non-tool block. CC closes text/thinking before tool_use. */
+  openBlockIndex: number | undefined
   seenFirstChunk: boolean
 }
 
@@ -104,22 +113,34 @@ function _defaultAccumulator(): _TurnAccumulator {
   return {
     messageId: null,
     contentBlocks: [],
+    accumulatedText: '',
+    emittedTextLength: 0,
+    shouldBufferTextDeltas: false,
     usage: { input_tokens: 0, output_tokens: 0 },
     stopReason: 'end_turn',
-    blockIndex: 0,
+    blockIndex: -1,
     toolBlockCounter: 0,
     thinkingBlockIndex: undefined,
+    openBlockIndex: undefined,
     seenFirstChunk: false,
   }
 }
 
+function firstToolCallTextOffset(text: string): number {
+  const braceOffset = text.indexOf('{')
+  const tagOffset = text.indexOf(TEXTUAL_TOOL_CALL_OPEN)
+  if (braceOffset < 0) return tagOffset
+  if (tagOffset < 0) return braceOffset
+  return Math.min(braceOffset, tagOffset)
+}
+
 // ---------------------------------------------------------------------------
 // Helper: extract usage from an AssistantChunkFrame done-trailer.
 //
 // Spec 032 does not currently define a typed usage payload on the frame itself;
 // the Python backend is expected to embed usage counts in the frame's `trailer`
 // extra fields or in a sibling ephemeral dict.  Until the backend-side contract
-// is finalised in Spec 032 US4, we read from `(frame as any).usage` first
+// is finalised in Spec 032 US4, we read from the typed legacy `usage` field first
 // (a forward-compatible extension field the backend may include) and fall back
 // to zeros.  A TODO(T091) marks the binding point for the actual backend wiring.
 // ---------------------------------------------------------------------------
@@ -299,6 +320,9 @@ export class LLMClient {
         ...(params.system !== undefined ? { system: params.system } : {}),
         max_tokens: params.max_tokens,
         ...(params.temperature !== undefined ? { temperature: params.temperature } : {}),
+        ...(params.reasoning_mode !== undefined
+          ? { reasoning_mode: params.reasoning_mode }
+          : {}),
       }
 
       // ----------------------------------------------------------------
@@ -339,11 +363,206 @@ export class LLMClient {
       //     primitive bridge for all tool dispatch; no server-side tools
       // ----------------------------------------------------------------
       let streamDone = false
+      const model = this.model
+      const ensureMessageStart = function* (
+        messageId: string,
+      ): Generator<UmmayaRawMessageStreamEvent, void, unknown> {
+        if (acc.seenFirstChunk) return
+        acc.seenFirstChunk = true
+        acc.messageId = messageId
+        yield {
+          type: 'message_start',
+          message: {
+            id: messageId,
+            role: 'assistant',
+            model,
+          },
+        } satisfies UmmayaRawMessageStreamEvent
+      }
+
+      const closeOpenBlock = function* (): Generator<
+        UmmayaRawMessageStreamEvent,
+        void,
+        unknown
+      > {
+        if (acc.openBlockIndex === undefined) return
+        yield {
+          type: 'content_block_stop',
+          index: acc.openBlockIndex,
+        } satisfies UmmayaRawMessageStreamEvent
+        acc.openBlockIndex = undefined
+      }
+
+      const ensureTextBlock = function* (): Generator<
+        UmmayaRawMessageStreamEvent,
+        void,
+        unknown
+      > {
+        if (acc.openBlockIndex === acc.blockIndex && acc.blockIndex >= 0) {
+          return
+        }
+        yield* closeOpenBlock()
+        const textIndex = acc.contentBlocks.length
+        acc.blockIndex = textIndex
+        acc.contentBlocks[textIndex] = { type: 'text', text: '' }
+        acc.openBlockIndex = textIndex
+        yield {
+          type: 'content_block_start',
+          index: textIndex,
+          content_block: { type: 'text', text: '' },
+        } satisfies UmmayaRawMessageStreamEvent
+      }
+
+      const ensureThinkingBlock = function* (): Generator<
+        UmmayaRawMessageStreamEvent,
+        void,
+        unknown
+      > {
+        if (
+          acc.thinkingBlockIndex !== undefined &&
+          acc.openBlockIndex === acc.thinkingBlockIndex
+        ) {
+          return
+        }
+        yield* closeOpenBlock()
+        const thinkingIdx = acc.contentBlocks.length
+        acc.thinkingBlockIndex = thinkingIdx
+        acc.contentBlocks[thinkingIdx] = { type: 'thinking', thinking: '' }
+        acc.openBlockIndex = thinkingIdx
+        yield {
+          type: 'content_block_start',
+          index: thinkingIdx,
+          content_block: { type: 'thinking', thinking: '' },
+        } satisfies UmmayaRawMessageStreamEvent
+      }
+
+      const appendVisibleTextDelta = function* (
+        text: string,
+        previousTextLength: number,
+      ): Generator<UmmayaRawMessageStreamEvent, void, unknown> {
+        if (text.length === 0) return
+        yield* ensureTextBlock()
+        yield {
+          type: 'content_block_delta',
+          index: acc.blockIndex,
+          delta: { type: 'text_delta', text },
+        } satisfies UmmayaRawMessageStreamEvent
+
+        const existing = acc.contentBlocks[acc.blockIndex]
+        if (existing && existing.type === 'text') {
+          existing.text += text
+        } else {
+          acc.contentBlocks[acc.blockIndex] = { type: 'text', text }
+        }
+        acc.emittedTextLength = previousTextLength + text.length
+      }
+
+      const appendAssistantText = function* (
+        text: string,
+      ): Generator<UmmayaRawMessageStreamEvent, void, unknown> {
+        if (text.length === 0) return
+        const previousTextLength = acc.accumulatedText.length
+        const bufferOffset = firstToolCallTextOffset(text)
+        const startsBuffering = !acc.shouldBufferTextDeltas && bufferOffset >= 0
+        if (startsBuffering) acc.shouldBufferTextDeltas = true
+        acc.accumulatedText += text
+        if (startsBuffering) {
+          if (bufferOffset > 0) {
+            yield* appendVisibleTextDelta(
+              text.slice(0, bufferOffset),
+              previousTextLength,
+            )
+          }
+          return
+        }
+        if (!acc.shouldBufferTextDeltas) {
+          yield* appendVisibleTextDelta(text, previousTextLength)
+        }
+      }
+
+      const flushBufferedText = function* (): Generator<
+        UmmayaRawMessageStreamEvent,
+        void,
+        unknown
+      > {
+        if (acc.accumulatedText.length <= acc.emittedTextLength) return
+        yield* appendVisibleTextDelta(
+          acc.accumulatedText.slice(acc.emittedTextLength),
+          acc.emittedTextLength,
+        )
+      }
+
+      const flushPreludeBeforeRawJsonToolUse = function* (
+        prelude: string,
+      ): Generator<UmmayaRawMessageStreamEvent, void, unknown> {
+        if (prelude.length <= acc.emittedTextLength) return
+        yield* appendVisibleTextDelta(
+          prelude.slice(acc.emittedTextLength),
+          acc.emittedTextLength,
+        )
+      }
+
+      const appendRawJsonToolUseBlock = function* (params: {
+        readonly name: string
+        readonly input: Record<string, unknown>
+        readonly id?: string
+      }): Generator<UmmayaRawMessageStreamEvent, void, unknown> {
+        const toolBlockIndex = acc.contentBlocks.length
+        acc.toolBlockCounter += 1
+        const toolUseId = params.id ?? 'call_raw_json_tool_0'
+        yield {
+          type: 'content_block_start',
+          index: toolBlockIndex,
+          content_block: {
+            type: 'tool_use',
+            id: toolUseId,
+            name: params.name,
+            input: params.input,
+          },
+        } satisfies UmmayaRawMessageStreamEvent
+        yield {
+          type: 'content_block_stop',
+          index: toolBlockIndex,
+        } satisfies UmmayaRawMessageStreamEvent
+        acc.contentBlocks[toolBlockIndex] = {
+          type: 'tool_use',
+          id: toolUseId,
+          name: params.name,
+          input: params.input,
+        }
+        acc.stopReason = 'tool_use'
+      }
 
       for await (const frame of this.bridge.frames()) {
         // Filter: only process frames for this turn's correlation_id.
         if (frame.correlation_id !== correlationId) continue
 
+        // ---- ProgressEventFrame ----------------------------------------
+        // Deterministic harness progress. This is safe UI state, not provider
+        // reasoning. It paints even when reasoning mode suppresses thinking.
+        if (frame.kind === 'progress_event') {
+          const progress = frame as ProgressEventFrame
+          yield* ensureMessageStart(`progress-${correlationId}`)
+          yield* ensureTextBlock()
+
+          const progressText = `${
+            progress.message_ko ?? progress.message_en ?? progress.phase
+          }\n`
+          yield {
+            type: 'content_block_delta',
+            index: acc.blockIndex,
+            delta: {
+              type: 'text_delta',
+              text: progressText,
+            },
+          } satisfies UmmayaRawMessageStreamEvent
+          const existing = acc.contentBlocks[acc.blockIndex]
+          if (existing && existing.type === 'text') {
+            existing.text += progressText
+          }
+          continue
+        }
+
         // ---- AssistantChunkFrame ----------------------------------------
         // CC reference: services/api/claude.ts:1980-2169 (the message_start +
         // content_block_start + content_block_delta + content_block_stop
@@ -356,26 +575,7 @@ export class LLMClient {
             // CC reference: services/api/claude.ts:1980 (message_start),
             //               services/api/claude.ts:2019 (text content_block_start).
             if (!acc.seenFirstChunk) {
-              acc.seenFirstChunk = true
-              acc.messageId = chunk.message_id
-
-              yield {
-                type: 'message_start',
-                message: {
-                  id: chunk.message_id,
-                  role: 'assistant',
-                  model: this.model,
-                },
-              } satisfies UmmayaRawMessageStreamEvent
-
-              yield {
-                type: 'content_block_start',
-                index: 0,
-                content_block: { type: 'text', text: '' },
-              } satisfies UmmayaRawMessageStreamEvent
-
-              acc.blockIndex = 0
-              acc.contentBlocks[0] = { type: 'text', text: '' }
+              yield* ensureMessageStart(chunk.message_id)
             }
 
             // Thinking delta — K-EXAONE's reasoning_content channel arrives
@@ -384,17 +584,8 @@ export class LLMClient {
             // `type: 'thinking'` blocks and route them to the
             // AssistantThinkingMessage component (∴ Thinking dim italic).
             if (chunk.thinking && chunk.thinking.length > 0) {
-              if (acc.thinkingBlockIndex === undefined) {
-                const thinkingIdx = acc.contentBlocks.length
-                acc.thinkingBlockIndex = thinkingIdx
-                yield {
-                  type: 'content_block_start',
-                  index: thinkingIdx,
-                  content_block: { type: 'thinking', thinking: '' },
-                } satisfies UmmayaRawMessageStreamEvent
-                acc.contentBlocks[thinkingIdx] = { type: 'thinking', thinking: '' }
-              }
-              const thinkingIdx = acc.thinkingBlockIndex
+              yield* ensureThinkingBlock()
+              const thinkingIdx = acc.thinkingBlockIndex!
               yield {
                 type: 'content_block_delta',
                 index: thinkingIdx,
@@ -408,20 +599,7 @@ export class LLMClient {
 
             // Emit text delta (even if delta is empty — forward compat).
             if (chunk.delta.length > 0) {
-              yield {
-                type: 'content_block_delta',
-                index: acc.blockIndex,
-                delta: { type: 'text_delta', text: chunk.delta },
-              } satisfies UmmayaRawMessageStreamEvent
-
-              // Accumulate text into the content block for the final object.
-              const existing = acc.contentBlocks[acc.blockIndex]
-              if (existing && existing.type === 'text') {
-                existing.text += chunk.delta
-              } else {
-                // First delta for this block index.
-                acc.contentBlocks[acc.blockIndex] = { type: 'text', text: chunk.delta }
-              }
+              yield* appendAssistantText(chunk.delta)
             }
           } else {
             // done=true: terminal chunk (V2 invariant satisfied here).
@@ -429,33 +607,42 @@ export class LLMClient {
             // If we never saw a first chunk (edge: backend sends done=true
             // immediately on an empty response), bootstrap the message events.
             if (!acc.seenFirstChunk) {
-              acc.seenFirstChunk = true
-              acc.messageId = chunk.message_id
-              yield {
-                type: 'message_start',
-                message: { id: chunk.message_id, role: 'assistant', model: this.model },
-              } satisfies UmmayaRawMessageStreamEvent
-              yield {
-                type: 'content_block_start',
-                index: 0,
-                content_block: { type: 'text', text: '' },
-              } satisfies UmmayaRawMessageStreamEvent
-              acc.blockIndex = 0
+              yield* ensureMessageStart(chunk.message_id)
             }
 
             // Emit any final delta text if present.
             if (chunk.delta.length > 0) {
-              yield {
-                type: 'content_block_delta',
-                index: acc.blockIndex,
-                delta: { type: 'text_delta', text: chunk.delta },
-              } satisfies UmmayaRawMessageStreamEvent
-              const existing = acc.contentBlocks[acc.blockIndex]
-              if (existing && existing.type === 'text') {
-                existing.text += chunk.delta
-              } else {
-                acc.contentBlocks[acc.blockIndex] = { type: 'text', text: chunk.delta }
+              yield* appendAssistantText(chunk.delta)
+            }
+
+            const textualToolUse = extractTextualToolCallProposals({
+              text: acc.accumulatedText,
+            })
+            const rawJsonToolUse = textualToolUse === undefined
+              ? parseTrailingRawJsonToolCallProposal({
+                  text: acc.accumulatedText,
+                })
+              : undefined
+            if (textualToolUse !== undefined || rawJsonToolUse !== undefined) {
+              const prelude = textualToolUse?.text ?? rawJsonToolUse?.prelude ?? ''
+              yield* flushPreludeBeforeRawJsonToolUse(prelude)
+              yield* closeOpenBlock()
+              const proposals = textualToolUse?.proposals ??
+                (rawJsonToolUse !== undefined ? [rawJsonToolUse.proposal] : [])
+              for (let index = 0; index < proposals.length; index += 1) {
+                const proposal = proposals[index]
+                if (!proposal) continue
+                yield* appendRawJsonToolUseBlock({
+                  name: proposal.name,
+                  input: proposal.input,
+                  id: textualToolUse !== undefined
+                    ? `call_textual_tool_${index}`
+                    : 'call_raw_json_tool_0',
+                })
               }
+              acc.accumulatedText = prelude
+            } else if (acc.shouldBufferTextDeltas) {
+              yield* flushBufferedText()
             }
 
             // Extract usage from the done-frame.
@@ -463,7 +650,7 @@ export class LLMClient {
             acc.usage = usage
 
             // CC reference: services/api/claude.ts:2171 (content_block_stop).
-            yield { type: 'content_block_stop', index: acc.blockIndex } satisfies UmmayaRawMessageStreamEvent
+            yield* closeOpenBlock()
 
             // CC reference: services/api/claude.ts:2213 (message_delta with
             // stop_reason + usage).
@@ -490,6 +677,11 @@ export class LLMClient {
         // initial content_block_start payload.
         else if (frame.kind === 'tool_call') {
           const toolFrame = frame as ToolCallFrame
+          yield* ensureMessageStart(`tool-${correlationId}`)
+          if (acc.shouldBufferTextDeltas) {
+            yield* flushBufferedText()
+          }
+          yield* closeOpenBlock()
           // tool_call frames may arrive interleaved with text streaming AND
           // thinking streaming in a multi-turn / parallel-tool / K-EXAONE
           // reasoning scenario. Allocate the tool block at the next free
@@ -526,6 +718,17 @@ export class LLMClient {
             name: toolFrame.name,
             input: toolFrame.arguments as Record<string, unknown>,
           }
+
+          acc.stopReason = 'tool_use'
+          yield {
+            type: 'message_delta',
+            delta: { stop_reason: 'tool_use' },
+            usage: acc.usage,
+          } satisfies UmmayaRawMessageStreamEvent
+          yield { type: 'message_stop' } satisfies UmmayaRawMessageStreamEvent
+
+          streamDone = true
+          break
         }
 
         // ---- ToolResultFrame (I-D5 + Epic ζ smoke checkpoint, FR-013) ----

package/tui/src/ipc/llmTypes.ts

@@ -66,6 +66,7 @@ export type UmmayaMessageStreamParams = {
   tools?: UmmayaToolDefinition[]
   max_tokens: number
   temperature?: number
+  reasoning_mode?: import('../utils/kExaoneReasoning.js').ReasoningMode
   metadata?: Record<string, string>
 }
 
@@ -121,10 +122,24 @@ export type UmmayaThinkingDelta = {
   thinking: string
 }
 
+export type UmmayaProgressDelta = {
+  type: 'progress_event'
+  phase: 'analysis' | 'tool_selection' | 'tool_call' | 'tool_result' | 'answer_synthesis'
+  message_ko: string
+  message_en: string
+  safe_to_persist: boolean
+  tool_id?: string | null
+  call_id?: string | null
+}
+
 export type UmmayaContentBlockDelta = {
   type: 'content_block_delta'
   index: number
-  delta: UmmayaTextDelta | UmmayaInputJsonDelta | UmmayaThinkingDelta
+  delta:
+    | UmmayaTextDelta
+    | UmmayaInputJsonDelta
+    | UmmayaThinkingDelta
+    | UmmayaProgressDelta
 }
 
 export type UmmayaContentBlockStop = {