ummaya 0.2.4 → 0.2.5

package/tui/src/services/api/backendChat/streaming.ts

@@ -0,0 +1,430 @@
+import { randomUUID } from 'crypto'
+import { APIUserAbortError } from 'src/sdk-compat.js'
+import {
+  getOrCreateUmmayaBridge,
+  getUmmayaBridgeSessionId,
+} from '../../../ipc/bridgeSingleton.js'
+import type {
+  ChatRequestFrame,
+  IPCFrame,
+} from '../../../ipc/frames.generated.js'
+import { buildChatMessagesFromTranscript } from '../../../query/chatMessagesBuilder.js'
+import { getToolDefinitionsForFrame } from '../../../query/toolSerialization.js'
+import { assertFriendliApiKeyForUse } from '../../../utils/auth.js'
+import { createAssistantMessage } from '../../../utils/assistantMessageFactories.js'
+import {
+  extractTextualToolCallProposals,
+  parseTrailingRawJsonToolCallProposal,
+} from '../../../utils/rawJsonToolCall.js'
+import {
+  createContentBlockStopEvent,
+  createMessageDeltaEvent,
+  createMessageStartStreamEvent,
+  createMessageStopEvent,
+  createTextBlockStartEvent,
+  createTextDeltaEvent,
+  createThinkingBlockStartEvent,
+  createThinkingDeltaEvent,
+  createToolUseBlockStartEvent,
+} from './events.js'
+import { createFinalAssistantMessage } from './finalMessage.js'
+import { toNonEmptyMessages } from './frame.js'
+import {
+  createBackendChatState,
+  hasAssistantPayload,
+  type BackendChatParams,
+  type BackendChatState,
+} from './types.js'
+
+const LLM_STREAM_ERROR_CODE = 'llm_stream_error'
+const STREAM_TIMEOUT_PATTERN = /\b(?:timeout|timed out|idle)\b/iu
+const LLM_STREAM_TIMEOUT_HANDOFF =
+  'K-EXAONE 응답이 지연되어 이번 요청을 이어갈 수 없습니다. 잠시 후 다시 시도해 주세요.'
+const DEFAULT_FRAME_IDLE_TIMEOUT_MS = 90_000
+const TEXTUAL_TOOL_CALL_OPEN = '<tool_call>'
+
+export async function* queryModelWithStreaming(
+  params: BackendChatParams,
+): AsyncGenerator<unknown> {
+  const { messages, signal } = params
+  assertFriendliApiKeyForUse()
+
+  const correlationId = randomUUID()
+  const messageUuid = randomUUID()
+  const innerMessageId = randomUUID()
+  const turnStartedAt = performance.now()
+  const bridge = getOrCreateUmmayaBridge()
+  const requestFrame: ChatRequestFrame = {
+    session_id: getUmmayaBridgeSessionId(),
+    correlation_id: correlationId,
+    ts: new Date().toISOString(),
+    role: 'tui',
+    kind: 'chat_request',
+    messages: toNonEmptyMessages(buildChatMessagesFromTranscript(messages)),
+    tools: await getToolDefinitionsForFrame(),
+  }
+
+  yield { type: 'stream_request_start' as const }
+
+  const sent = bridge.send(requestFrame)
+  if (!sent) {
+    throw new Error('UMMAYA bridge send failed (backend exited)')
+  }
+
+  const persistThinking = process.env.UMMAYA_PERSIST_THINKING === '1'
+  const state = createBackendChatState()
+  const frameIdleTimeoutMs = getFrameIdleTimeoutMs()
+  const frameIterator = bridge.frames()[Symbol.asyncIterator]()
+  let correlatedFrameDeadline = performance.now() + frameIdleTimeoutMs
+
+  while (true) {
+    if (signal?.aborted) throw new APIUserAbortError()
+    const timeoutMs = correlatedFrameDeadline - performance.now()
+    const nextFrame = await readNextFrame(frameIterator, timeoutMs)
+    if (nextFrame === 'timeout') {
+      yield createAssistantMessage({
+        content: LLM_STREAM_TIMEOUT_HANDOFF,
+      })
+      yield* stopOpenBlocks(state)
+      if (state.messageStartEmitted) yield createMessageStopEvent()
+      return
+    }
+    if (nextFrame.done) break
+    const frame = nextFrame.value
+    if (frame.correlation_id !== correlationId) continue
+    correlatedFrameDeadline = performance.now() + frameIdleTimeoutMs
+
+    if (frame.kind === 'assistant_chunk') {
+      yield* handleAssistantChunk({
+        frame,
+        state,
+        persistThinking,
+        turnStartedAt,
+        innerMessageId,
+        messageUuid,
+      })
+      if (frame.done) return
+    } else if (frame.kind === 'tool_call') {
+      yield* handleToolCallFrame({
+        frame,
+        state,
+        persistThinking,
+        turnStartedAt,
+        innerMessageId,
+        messageUuid,
+      })
+      return
+    } else if (frame.kind === 'error') {
+      yield createAssistantMessage({
+        content: formatBackendErrorMessage(frame),
+      })
+      yield* stopOpenBlocks(state)
+      if (state.messageStartEmitted) yield createMessageStopEvent()
+      return
+    }
+  }
+
+  if (hasAssistantPayload(state, persistThinking) || !state.messageStartEmitted) {
+    yield createFinalAssistantMessage({
+      accumulated: state.accumulated,
+      accumulatedThinking: state.accumulatedThinking,
+      messageUuid,
+      innerMessageId,
+      pendingContentBlocks: state.pendingContentBlocks,
+      persistThinking,
+    })
+  }
+  if (state.messageStartEmitted) {
+    yield* stopOpenBlocks(state)
+    yield createMessageStopEvent()
+  }
+}
+
+function getFrameIdleTimeoutMs(): number {
+  const raw = process.env.UMMAYA_TUI_FRAME_IDLE_TIMEOUT_MS
+  if (raw === undefined) return DEFAULT_FRAME_IDLE_TIMEOUT_MS
+  const parsed = Number.parseInt(raw, 10)
+  if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_FRAME_IDLE_TIMEOUT_MS
+  return parsed
+}
+
+async function readNextFrame(
+  iterator: AsyncIterator<IPCFrame>,
+  timeoutMs: number,
+): Promise<IteratorResult<IPCFrame> | 'timeout'> {
+  if (timeoutMs <= 0) return 'timeout'
+  let timeoutId: ReturnType<typeof setTimeout> | undefined
+  const timeout = new Promise<'timeout'>(resolve => {
+    timeoutId = setTimeout(() => resolve('timeout'), timeoutMs)
+  })
+  const result = await Promise.race([iterator.next(), timeout])
+  if (timeoutId !== undefined) clearTimeout(timeoutId)
+  if (result === 'timeout') {
+    void iterator.return?.()
+  }
+  return result
+}
+
+function formatBackendErrorMessage(
+  frame: Extract<IPCFrame, { kind?: 'error' }>,
+): string {
+  if (
+    frame.code === LLM_STREAM_ERROR_CODE &&
+    STREAM_TIMEOUT_PATTERN.test(frame.message)
+  ) {
+    return LLM_STREAM_TIMEOUT_HANDOFF
+  }
+  return `[UMMAYA backend error] ${frame.message}`
+}
+
+function* handleAssistantChunk({
+  frame,
+  state,
+  persistThinking,
+  turnStartedAt,
+  innerMessageId,
+  messageUuid,
+}: {
+  readonly frame: Extract<IPCFrame, { kind?: 'assistant_chunk' }>
+  readonly state: BackendChatState
+  readonly persistThinking: boolean
+  readonly turnStartedAt: number
+  readonly innerMessageId: string
+  readonly messageUuid: string
+}): Generator<unknown> {
+  yield* startMessageIfNeeded(state, innerMessageId, turnStartedAt)
+  const thinkingText = frame.thinking ?? ''
+  if (thinkingText.length > 0) yield* appendThinking(state, thinkingText, persistThinking)
+
+  const deltaText = frame.delta ?? ''
+  state.accumulated += deltaText
+  if (deltaText.length > 0) yield* appendText(state, deltaText)
+
+  if (!frame.done) return
+  const textualToolUse = extractTextualToolCallProposals({
+    text: state.accumulated,
+  })
+  const rawJsonToolUse = textualToolUse === undefined
+    ? parseTrailingRawJsonToolCallProposal({
+        text: state.accumulated,
+      })
+    : undefined
+  if (
+    (textualToolUse !== undefined || rawJsonToolUse !== undefined) &&
+    state.pendingContentBlocks.length === 0
+  ) {
+    const prelude = textualToolUse?.text ?? rawJsonToolUse?.prelude ?? ''
+    yield* flushTextPreludeBeforeRawJsonToolUse(state, prelude)
+    yield* stopOpenBlocks(state)
+    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({
+        state,
+        name: proposal.name,
+        input: proposal.input,
+        id: textualToolUse !== undefined
+          ? `call_textual_tool_${index}`
+          : 'call_raw_json_tool_0',
+      })
+    }
+    state.accumulated = prelude
+    yield createFinalAssistantMessage({
+      accumulated: state.accumulated,
+      accumulatedThinking: state.accumulatedThinking,
+      messageUuid,
+      innerMessageId,
+      pendingContentBlocks: state.pendingContentBlocks,
+      persistThinking,
+    })
+    yield createMessageDeltaEvent('tool_use')
+    yield createMessageStopEvent()
+    return
+  }
+  if (state.shouldBufferTextDeltas) {
+    yield* flushBufferedText(state)
+  }
+  yield* stopOpenBlocks(state)
+  if (hasAssistantPayload(state, persistThinking) || !state.messageStartEmitted) {
+    yield createFinalAssistantMessage({
+      accumulated: state.accumulated,
+      accumulatedThinking: state.accumulatedThinking,
+      messageUuid,
+      innerMessageId,
+      pendingContentBlocks: state.pendingContentBlocks,
+      persistThinking,
+    })
+  }
+  if (state.messageStartEmitted) {
+    yield createMessageDeltaEvent('end_turn')
+    yield createMessageStopEvent()
+  }
+}
+
+function* handleToolCallFrame({
+  frame,
+  state,
+  persistThinking,
+  turnStartedAt,
+  innerMessageId,
+  messageUuid,
+}: {
+  readonly frame: Extract<IPCFrame, { kind?: 'tool_call' }>
+  readonly state: BackendChatState
+  readonly persistThinking: boolean
+  readonly turnStartedAt: number
+  readonly innerMessageId: string
+  readonly messageUuid: string
+}): Generator<unknown> {
+  yield* startMessageIfNeeded(state, innerMessageId, turnStartedAt)
+  if (state.shouldBufferTextDeltas) {
+    yield* flushBufferedText(state)
+  }
+  yield* stopOpenBlocks(state)
+
+  const toolUseBlock = {
+    type: 'tool_use' as const,
+    id: frame.call_id,
+    name: frame.name,
+    input: frame.arguments,
+  }
+  state.pendingContentBlocks.push(toolUseBlock)
+  const toolBlockIndex = state.nextContentBlockIndex
+  state.nextContentBlockIndex += 1
+
+  yield createToolUseBlockStartEvent(toolBlockIndex, toolUseBlock)
+  yield createContentBlockStopEvent(toolBlockIndex)
+  yield createFinalAssistantMessage({
+    accumulated: state.accumulated,
+    accumulatedThinking: state.accumulatedThinking,
+    messageUuid,
+    innerMessageId,
+    pendingContentBlocks: state.pendingContentBlocks,
+    persistThinking,
+  })
+  yield createMessageDeltaEvent('tool_use')
+  yield createMessageStopEvent()
+}
+
+function* startMessageIfNeeded(
+  state: BackendChatState,
+  innerMessageId: string,
+  turnStartedAt: number,
+): Generator<unknown> {
+  if (state.messageStartEmitted) return
+  yield createMessageStartStreamEvent(innerMessageId, performance.now() - turnStartedAt)
+  state.messageStartEmitted = true
+}
+
+function* appendThinking(
+  state: BackendChatState,
+  text: string,
+  persistThinking: boolean,
+): Generator<unknown> {
+  if (state.thinkingBlockIndex === null) {
+    yield createThinkingBlockStartEvent(state.nextContentBlockIndex)
+    state.thinkingBlockIndex = state.nextContentBlockIndex
+    state.nextContentBlockIndex += 1
+  }
+  if (persistThinking) state.accumulatedThinking += text
+  yield createThinkingDeltaEvent(state.thinkingBlockIndex, text)
+}
+
+function* appendText(state: BackendChatState, text: string): Generator<unknown> {
+  const previousTextLength = state.accumulated.length - text.length
+  const bufferOffset = firstToolCallTextOffset(text)
+  const startsBuffering = !state.shouldBufferTextDeltas && bufferOffset >= 0
+  if (startsBuffering) state.shouldBufferTextDeltas = true
+  if (startsBuffering) {
+    if (bufferOffset > 0) {
+      yield* appendVisibleTextDelta(
+        state,
+        text.slice(0, bufferOffset),
+        previousTextLength,
+      )
+    }
+    return
+  }
+  if (state.shouldBufferTextDeltas) return
+  yield* appendVisibleTextDelta(state, text, previousTextLength)
+}
+
+function* appendVisibleTextDelta(
+  state: BackendChatState,
+  text: string,
+  previousTextLength: number,
+): Generator<unknown> {
+  if (text.length === 0) return
+  if (state.thinkingBlockIndex !== null && !state.thinkingBlockStopped) {
+    yield createContentBlockStopEvent(state.thinkingBlockIndex)
+    state.thinkingBlockStopped = true
+  }
+  if (state.textBlockIndex === null) {
+    yield createTextBlockStartEvent(state.nextContentBlockIndex)
+    state.textBlockIndex = state.nextContentBlockIndex
+    state.nextContentBlockIndex += 1
+  }
+  yield createTextDeltaEvent(state.textBlockIndex, text)
+  state.emittedTextLength = previousTextLength + text.length
+}
+
+function* flushBufferedText(state: BackendChatState): Generator<unknown> {
+  if (state.accumulated.length <= state.emittedTextLength) return
+  yield* appendVisibleTextDelta(
+    state,
+    state.accumulated.slice(state.emittedTextLength),
+    state.emittedTextLength,
+  )
+}
+
+function* flushTextPreludeBeforeRawJsonToolUse(
+  state: BackendChatState,
+  prelude: string,
+): Generator<unknown> {
+  if (prelude.length <= state.emittedTextLength) return
+  yield* appendVisibleTextDelta(
+    state,
+    prelude.slice(state.emittedTextLength),
+    state.emittedTextLength,
+  )
+}
+
+function* appendRawJsonToolUseBlock(params: {
+  readonly state: BackendChatState
+  readonly name: string
+  readonly input: Record<string, unknown>
+  readonly id?: string
+}): Generator<unknown> {
+  const toolUseBlock = {
+    type: 'tool_use' as const,
+    id: params.id ?? 'call_raw_json_tool_0',
+    name: params.name,
+    input: params.input,
+  }
+  params.state.pendingContentBlocks.push(toolUseBlock)
+  const toolBlockIndex = params.state.nextContentBlockIndex
+  params.state.nextContentBlockIndex += 1
+  yield createToolUseBlockStartEvent(toolBlockIndex, toolUseBlock)
+  yield createContentBlockStopEvent(toolBlockIndex)
+}
+
+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)
+}
+
+function* stopOpenBlocks(state: BackendChatState): Generator<unknown> {
+  if (state.thinkingBlockIndex !== null && !state.thinkingBlockStopped) {
+    yield createContentBlockStopEvent(state.thinkingBlockIndex)
+    state.thinkingBlockStopped = true
+  }
+  if (state.textBlockIndex !== null && !state.textBlockStopped) {
+    yield createContentBlockStopEvent(state.textBlockIndex)
+    state.textBlockStopped = true
+  }
+}

package/tui/src/services/api/backendChat/types.ts

@@ -0,0 +1,62 @@
+import type { ToolCallFrame } from '../../../ipc/frames.generated.js'
+
+export type BackendChatParams = {
+  readonly messages: readonly unknown[]
+  readonly systemPrompt: unknown
+  readonly thinkingConfig?: unknown
+  readonly tools?: unknown
+  readonly signal?: AbortSignal
+  readonly options?: {
+    readonly model?: string
+    readonly querySource?: string
+    readonly [key: string]: unknown
+  }
+}
+
+export type PendingToolUseBlock = {
+  readonly type: 'tool_use'
+  readonly id: string
+  readonly name: string
+  readonly input: ToolCallFrame['arguments']
+}
+
+export type BackendChatState = {
+  accumulated: string
+  accumulatedThinking: string
+  emittedTextLength: number
+  messageStartEmitted: boolean
+  nextContentBlockIndex: number
+  shouldBufferTextDeltas: boolean
+  textBlockIndex: number | null
+  textBlockStopped: boolean
+  thinkingBlockIndex: number | null
+  thinkingBlockStopped: boolean
+  readonly pendingContentBlocks: PendingToolUseBlock[]
+}
+
+export function createBackendChatState(): BackendChatState {
+  return {
+    accumulated: '',
+    accumulatedThinking: '',
+    emittedTextLength: 0,
+    messageStartEmitted: false,
+    nextContentBlockIndex: 0,
+    shouldBufferTextDeltas: false,
+    textBlockIndex: null,
+    textBlockStopped: false,
+    thinkingBlockIndex: null,
+    thinkingBlockStopped: false,
+    pendingContentBlocks: [],
+  }
+}
+
+export function hasAssistantPayload(
+  state: BackendChatState,
+  persistThinking: boolean,
+): boolean {
+  return (
+    state.accumulated.trimStart().length > 0 ||
+    state.pendingContentBlocks.length > 0 ||
+    (persistThinking && state.accumulatedThinking.length > 0)
+  )
+}

package/tui/src/services/api/backendChat.ts

@@ -0,0 +1 @@
+export { queryModelWithStreaming } from './backendChat/streaming.js'

package/tui/src/services/api/client.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // UMMAYA FriendliAI client shim for the CC-restored provider.
 //
-// services/api/claude.ts is the Claude Code streaming provider shape. This
+// services/api/ummaya.ts is the Claude Code streaming provider shape. This
 // module supplies the one sanctioned swap: Anthropic SDK transport becomes
 // FriendliAI's OpenAI-compatible /chat/completions endpoint. query.ts still
 // owns the agentic loop; backend stdio remains only the tool executor for
@@ -601,7 +601,7 @@ function convertToolChoice(
 }
 
 function sanitizeSchema(schema: Record<string, unknown>): Record<string, unknown> {
-  const clone = { ...schema }
+  const clone = inlineLocalJsonSchemaRefs(schema)
   delete clone.cache_control
   delete clone.defer_loading
   delete clone.eager_input_streaming
@@ -609,6 +609,69 @@ function sanitizeSchema(schema: Record<string, unknown>): Record<string, unknown
   return clone
 }
 
+function inlineLocalJsonSchemaRefs(schema: Record<string, unknown>): Record<string, unknown> {
+  const defs = isRecord(schema.$defs) ? schema.$defs : {}
+  const inlined = inlineSchemaNode(schema, defs, [])
+  if (!isRecord(inlined)) {
+    throw new Error('OpenAI tool parameters schema must be a JSON object')
+  }
+  return inlined
+}
+
+function inlineSchemaNode(
+  node: unknown,
+  defs: Record<string, unknown>,
+  stack: string[],
+): unknown {
+  if (Array.isArray(node)) {
+    return node.map(item => inlineSchemaNode(item, defs, stack))
+  }
+  if (!isRecord(node)) return node
+
+  const refName = localDefRefName(node.$ref)
+  if (refName) {
+    if (stack.includes(refName)) {
+      throw new Error(`Cyclic JSON Schema reference is not supported: #/$defs/${refName}`)
+    }
+    if (!Object.prototype.hasOwnProperty.call(defs, refName)) {
+      throw new Error(`Unknown JSON Schema reference: #/$defs/${refName}`)
+    }
+
+    const expanded = inlineSchemaNode(defs[refName], defs, [...stack, refName])
+    const siblings = Object.fromEntries(
+      Object.entries(node).filter(([key]) => key !== '$ref' && key !== '$defs'),
+    )
+    if (Object.keys(siblings).length === 0) return expanded
+    if (!isRecord(expanded)) {
+      throw new Error(`JSON Schema reference target must be an object: #/$defs/${refName}`)
+    }
+    return {
+      ...expanded,
+      ...Object.fromEntries(
+        Object.entries(siblings).map(([key, value]) => [
+          key,
+          inlineSchemaNode(value, defs, stack),
+        ]),
+      ),
+    }
+  }
+
+  return Object.fromEntries(
+    Object.entries(node)
+      .filter(([key]) => key !== '$defs')
+      .map(([key, value]) => [key, inlineSchemaNode(value, defs, stack)]),
+  )
+}
+
+function localDefRefName(ref: unknown): string | null {
+  if (typeof ref !== 'string' || !ref.startsWith('#/$defs/')) return null
+  return ref.slice('#/$defs/'.length).replace(/~1/g, '/').replace(/~0/g, '~')
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
 function systemToText(system: BetaMessageStreamParams['system']): string {
   if (!system) return ''
   if (typeof system === 'string') return system

package/tui/src/services/api/errorUtils.ts

@@ -36,7 +36,7 @@ export type ConnectionErrorDetails = {
 
 /**
  * Extracts connection error details from the error cause chain.
- * The Anthropic SDK wraps underlying errors in the `cause` property.
+ * The legacy SDK wraps underlying errors in the `cause` property.
  * This function walks the cause chain to find the root error code/message.
  */
 export function extractConnectionErrorDetails(
@@ -96,7 +96,7 @@ export function getSSLErrorHint(error: unknown): string | null {
   if (!details?.isSSLError) {
     return null
   }
-  return `SSL certificate error (${details.code}). If you are behind a corporate proxy or TLS-intercepting firewall, set NODE_EXTRA_CA_CERTS to your CA bundle path, or ask IT to allowlist *.anthropic.com. Run /doctor for details.`
+  return `SSL certificate error (${details.code}). If you are behind a corporate proxy or TLS-intercepting firewall, set NODE_EXTRA_CA_CERTS to your CA bundle path, or ask IT to allowlist the configured UMMAYA provider endpoint. Run /doctor for details.`
 }
 
 /**
@@ -136,7 +136,7 @@ export function sanitizeAPIError(apiError: APIError): string {
  * The actual message lives at different nesting levels depending on the provider:
  *
  * - Bedrock/proxy: `{ error: { message: "..." } }`
- * - Standard Anthropic API: `{ error: { error: { message: "..." } } }`
+ * - Provider API: `{ error: { error: { message: "..." } } }`
  *   (the outer `.error` is the response body, the inner `.error` is the API error)
  *
  * See also: `getErrorMessage` in `logging.ts` which handles the same shapes.
@@ -163,7 +163,7 @@ function hasNestedError(value: unknown): value is NestedAPIError {
  * a top-level `.message`.
  *
  * Checks two nesting levels (deeper first for specificity):
- * 1. `error.error.error.message` — standard Anthropic API shape
+ * 1. `error.error.error.message` — provider API shape
  * 2. `error.error.message` — Bedrock shape
  */
 function extractNestedErrorMessage(error: APIError): string | null {
@@ -176,7 +176,7 @@ function extractNestedErrorMessage(error: APIError): string | null {
   const narrowed: NestedAPIError = error
   const nested = narrowed.error
 
-  // Standard Anthropic API shape: { error: { error: { message } } }
+  // Provider API shape: { error: { error: { message } } }
   const deepMsg = nested?.error?.message
   if (typeof deepMsg === 'string' && deepMsg.length > 0) {
     const sanitized = sanitizeMessageHTML(deepMsg)

package/tui/src/services/api/errors.ts

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // SWAP/anti-anthropic-1p(2521): minimal stub for the byte-copied
-// services/api/claude.ts which references CC's Anthropic-API error envelopes.
+// services/api/ummaya.ts which references CC's Anthropic-API error envelopes.
 // UMMAYA surfaces errors via the IPC ErrorFrame (Spec 032) and never reaches
 // these helpers. Stubs preserve the import shape only.
 

package/tui/src/services/api/logging.ts

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 // SWAP/anti-anthropic-1p(2521): minimal stub for the byte-copied
-// services/api/claude.ts which references CC's Anthropic-API request/response
+// services/api/ummaya.ts which references CC's Anthropic-API request/response
 // telemetry. UMMAYA uses OTEL spans (Spec 021) and audit ledger (Spec 024)
 // instead. Stubs preserve the import shape; functions are no-ops because the
 // byte-copy has zero callers in UMMAYA.