查询循环

// query.ts — 简化版
export async function* query(
  opts: QueryOptions
): AsyncGenerator<StreamEvent | RequestStartEvent | Message> {
  // 外层 query() 是一个薄包装
  yield* queryLoop({
    messages: opts.messages,
    systemPrompt: opts.systemPrompt,
    model: opts.model,
    tools: opts.tools,
    canUseTool: opts.canUseTool,
    abortSignal: opts.abortSignal,
    usage: opts.usage,
  })
}

// queryLoop 内部状态类型
interface State {
  messages: Message[]
  toolUseContext: ToolUseContext
  autoCompactTracking: {
    tokenHistory: number[]
    lastCompactAt: number
  }
  maxOutputTokensRecoveryCount: number  // 上限 3
  turnCount: number
  transition: 'continue' | 'stop'
  stopHookActive: boolean
}

async function* queryLoop(
  opts: QueryLoopOptions
): AsyncGenerator<StreamEvent | RequestStartEvent | Message> {
  // 初始化状态
  const state: State = {
    messages: opts.messages,
    toolUseContext: {},
    autoCompactTracking: { tokenHistory: [], lastCompactAt: 0 },
    maxOutputTokensRecoveryCount: 0,
    turnCount: 0,
    transition: 'continue',
    stopHookActive: false,
  }

  // 主循环
  while (state.transition === 'continue') {
    state.turnCount++

    // 检查停止条件
    if (state.turnCount > opts.maxTurns) {
      state.transition = 'stop'
      break
    }

    // 执行 10 步管道（见下一个示例）
    yield* executeIterationPipeline(state, opts)
  }
}

// query/pipeline.ts — 简化版
async function* executeIterationPipeline(
  state: State,
  opts: QueryLoopOptions
): AsyncGenerator<StreamEvent | RequestStartEvent | Message> {

  // === 步骤 1: Skill 发现预取（异步，不阻塞） ===
  const skillPrefetch = prefetchSkillDiscovery(state.messages)

  // === 步骤 2: 工具结果预算 ===
  applyToolResultBudget(state.messages, {
    maxToolResultTokens: 50_000,  // 单个工具输出上限 50K tokens
  })

  // === 步骤 3: Snip 压缩 ===
  snipCompact(state.messages)  // 将大文本块替换为摘要

  // === 步骤 4: Micro-compact ===
  microCompact(state.messages)  // 移除冗余空白和格式

  // === 步骤 5: 上下文折叠 ===
  contextCollapse(state.messages, {
    preserveRecentTurns: 4,  // 保留最近 4 轮
  })

  // === 步骤 6: 自动压缩（基于 token 增长趋势） ===
  const compacted = await autoCompact(state.messages, state.autoCompactTracking)
  if (compacted) {
    state.autoCompactTracking.lastCompactAt = state.turnCount
  }

  // === 步骤 7: 系统提示词组装 ===
  await skillPrefetch  // 等待 Skill 预取完成
  const systemPrompt = assembleSystemPrompt(opts, state)

  // === 步骤 8: API 流式调用 ===
  yield { type: 'requestStart' } as RequestStartEvent
  const response = await streamApiCall({
    model: opts.model,
    system: systemPrompt,
    messages: state.messages,
    tools: opts.tools,
    abortSignal: opts.abortSignal,
  })

  // yield 流式事件
  for await (const event of response.stream) {
    yield event as StreamEvent
  }
  const assistantMessage = response.finalMessage
  yield assistantMessage

  // === 步骤 9: 工具执行 ===
  const toolCalls = extractToolCalls(assistantMessage)
  if (toolCalls.length > 0) {
    const toolResults = await executeTools(toolCalls, opts.canUseTool)
    state.messages.push(...toolResults)
    for (const result of toolResults) yield result
  } else {
    // 无工具调用 → Claude 主动结束
    state.transition = 'stop'
  }

  // === 步骤 10: Post-sampling 钩子 ===
  const hookResult = await runPostSamplingHooks(assistantMessage)
  if (hookResult?.stop) {
    state.stopHookActive = true
    state.transition = 'stop'
  }

  // 错误恢复：max_output_tokens
  if (response.stopReason === 'max_output_tokens') {
    if (state.maxOutputTokensRecoveryCount < 3) {
      state.maxOutputTokensRecoveryCount++
      state.messages.push({ role: 'user', content: 'Continue.' })
      // transition 保持 'continue'，进入下一轮
    } else {
      state.transition = 'stop'  // 超过 3 次重试上限
    }
  }

  // 更新 token 追踪
  state.autoCompactTracking.tokenHistory.push(
    response.usage.inputTokens
  )
}

// query/errorRecovery.ts — 简化版

// max_output_tokens 恢复
function handleMaxOutputTokens(
  state: State,
  response: ApiResponse
): void {
  if (response.stopReason !== 'max_output_tokens') return

  if (state.maxOutputTokensRecoveryCount < 3) {
    // 还有重试机会
    state.maxOutputTokensRecoveryCount++
    state.messages.push({
      role: 'user',
      content: 'Your response was cut off. Please continue from where you stopped.',
    })
    // state.transition 保持 'continue'
  } else {
    // 已重试 3 次，放弃
    state.transition = 'stop'
  }
}

// prompt_too_long 响应式压缩
async function handlePromptTooLong(
  state: State,
  error: ApiError
): Promise<boolean> {
  // 第一次尝试：温和压缩
  const gentleResult = await reactiveCompact(state.messages, {
    strategy: 'preserve-recent',
    targetReduction: 0.3,  // 减少 30% token
  })

  if (gentleResult.success) return true  // 重试

  // 第二次尝试：激进压缩
  const aggressiveResult = await aggressiveCompact(state.messages, {
    strategy: 'keep-first-last',  // 仅保留首尾消息
    targetReduction: 0.6,  // 减少 60% token
  })

  return aggressiveResult.success  // 成功则重试，否则放弃
}

// 停止条件检查
function checkStopConditions(state: State, opts: QueryLoopOptions): void {
  // 最大轮数
  if (state.turnCount >= opts.maxTurns) {
    state.transition = 'stop'
    return
  }

  // Token 预算
  if (opts.usage.totalTokens >= opts.budget) {
    state.transition = 'stop'
    return
  }

  // 停止钩子
  if (state.stopHookActive) {
    state.transition = 'stop'
    return
  }
}