ummaya 0.2.3 → 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
@@ -26,6 +26,11 @@ import {
 } from '../../sdk-compat.js'
 import { assertFriendliApiKeyForUse } from '../../utils/auth.js'
 import { getUserAgent } from '../../utils/http.js'
+import {
+  providerReasoningPayload,
+  resolveKExaoneReasoningPolicy,
+  type ReasoningMode,
+} from '../../utils/kExaoneReasoning.js'
 import { UMMAYA_K_EXAONE_MODEL } from '../../utils/model/constants.js'
 
 export const CLIENT_REQUEST_ID_HEADER = 'x-client-request-id'
@@ -41,6 +46,11 @@ type RequestOptions = {
   headers?: Record<string, string>
 }
 
+type FriendliMessageStreamParams = BetaMessageStreamParams & {
+  stream?: boolean
+  reasoning_mode?: ReasoningMode
+}
+
 type FriendliClientArgs = {
   apiKey?: string
   maxRetries: number
@@ -130,7 +140,7 @@ class FriendliMessagesCompatClient {
   readonly beta: {
     messages: {
       create: (
-        params: BetaMessageStreamParams & { stream?: boolean },
+        params: FriendliMessageStreamParams,
         options?: RequestOptions,
       ) => unknown
     }
@@ -159,7 +169,7 @@ class FriendliMessagesCompatClient {
   }
 
   private async streamWithResponse(
-    params: BetaMessageStreamParams & { stream?: boolean },
+    params: FriendliMessageStreamParams,
     options?: RequestOptions,
   ): Promise<{
     data: Stream<BetaRawMessageStreamEvent>
@@ -188,7 +198,7 @@ class FriendliMessagesCompatClient {
   }
 
   private async complete(
-    params: BetaMessageStreamParams,
+    params: FriendliMessageStreamParams,
     options?: RequestOptions,
   ): Promise<BetaMessage> {
     const response = await this.fetchChatCompletion(
@@ -279,6 +289,9 @@ class FriendliMessagesCompatClient {
     const toolStates = new Map<number, ToolStreamState>()
     let finalUsage: BetaUsage | undefined
     let stopReason: BetaMessage['stop_reason'] = 'end_turn'
+    const allowReasoning = resolveKExaoneReasoningPolicy({
+      explicitSessionMode: params.reasoning_mode,
+    }).includeReasoning
 
     const ensureMessageStart = function* () {
       if (messageStarted) return
@@ -301,6 +314,12 @@ class FriendliMessagesCompatClient {
     const ensureTextBlock = function* () {
       yield* ensureMessageStart()
       if (textBlockIndex === undefined) {
+        if (
+          thinkingBlockIndex !== undefined &&
+          openedBlocks.has(thinkingBlockIndex)
+        ) {
+          yield* closeNonToolBlocks()
+        }
         textBlockIndex = nextBlockIndex++
         openedBlocks.add(textBlockIndex)
         yield {
@@ -314,6 +333,9 @@ class FriendliMessagesCompatClient {
     const ensureThinkingBlock = function* () {
       yield* ensureMessageStart()
       if (thinkingBlockIndex === undefined) {
+        if (textBlockIndex !== undefined && openedBlocks.has(textBlockIndex)) {
+          yield* closeNonToolBlocks()
+        }
         thinkingBlockIndex = nextBlockIndex++
         openedBlocks.add(thinkingBlockIndex)
         yield {
@@ -385,7 +407,7 @@ class FriendliMessagesCompatClient {
 
         for (const choice of chunk.choices ?? []) {
           const delta = choice.delta ?? {}
-          if (delta.reasoning_content) {
+          if (delta.reasoning_content && allowReasoning) {
             yield* ensureThinkingBlock()
             yield {
               type: 'content_block_delta' as const,
@@ -454,17 +476,20 @@ class FriendliMessagesCompatClient {
 }
 
 function buildOpenAIPayload(
-  params: BetaMessageStreamParams & { stream?: boolean },
+  params: FriendliMessageStreamParams,
 ): Record<string, unknown> {
   const messages = convertMessages(params.messages, params.system)
   const tools = convertTools(params.tools)
+  const reasoning = providerReasoningPayload(
+    resolveKExaoneReasoningPolicy({
+      explicitSessionMode: params.reasoning_mode,
+    }),
+  )
   const payload: Record<string, unknown> = {
     model: params.model || UMMAYA_K_EXAONE_MODEL,
     messages,
     max_tokens: params.max_tokens,
-    chat_template_kwargs: {
-      enable_thinking: isTruthy(process.env.UMMAYA_K_EXAONE_THINKING),
-    },
+    ...reasoning,
     ...(params.temperature !== undefined ? { temperature: params.temperature } : {}),
     ...(tools.length > 0
       ? {
@@ -576,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
@@ -584,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
@@ -740,7 +828,3 @@ function resolveFetch(fetchOverride: unknown): FetchLike {
 function trimSlash(value: string): string {
   return value.replace(/\/+$/, '')
 }
-
-function isTruthy(value: string | undefined): boolean {
-  return value === '1' || value?.toLowerCase() === 'true' || value?.toLowerCase() === 'yes'
-}