store, _ := config.LoadStoreWithError()
pool := account.NewPool(store)
resolver := auth.NewResolver(store, pool, ...)
dsClient := dsclient.NewClient(store, resolver)
if err := dsClient.PreloadPow(ctx); err != nil {
  config.Logger.Warn("[PoW] init failed", ...)
} else {
  config.Logger.Info("[PoW] pure Go solver ready")
}

func BuildOpenAIPrompt(messagesRaw []any, toolsRaw any,
    traceID string, toolPolicy ToolChoicePolicy,
    thinkingEnabled bool) (string, []string) {
  messages := NormalizeOpenAIMessagesForPrompt(messagesRaw, traceID)
  toolNames := []string{}
  if tools, ok := toolsRaw.([]any); ok && len(tools) > 0 {
    messages, toolNames = injectToolPrompt(messages, tools, toolPolicy)
  }
  return prompt.MessagesPrepareWithThinking(messages, thinkingEnabled), toolNames
}

{
  "model": "gpt-4.1",
  "messages": [
    {"role": "system", "content": "你是天文学助手"},
    {"role": "user", "content": "太阳系有几大行星？"}
  ],
  "stream": true
}

type Pool struct {
  store                  *config.Store
  mu                     sync.Mutex
  queue                  []string
  inUse                  map[string]int
  waiters                []chan struct{}
  maxInflightPerAccount  int
  recommendedConcurrency int
  maxQueueSize           int
  globalMaxInflight      int
}

func (p *Pool) AcquireWait(ctx context.Context,
    target string, exclude map[string]bool) (config.Account, bool) {
  for {
    if ctx.Err() != nil { return config.Account{}, false }
    p.mu.Lock()
    if acc, ok := p.acquireLocked(target, exclude); ok {
      p.mu.Unlock(); return acc, true
    }
    if !p.canQueueLocked(target, exclude) {
      p.mu.Unlock(); return config.Account{}, false
    }
    waiter := make(chan struct{})
    p.waiters = append(p.waiters, waiter)
    p.mu.Unlock()
    select {
      case <-ctx.Done(): /* 客户端取消，登记销毁 */
      case <-waiter:    /* 有人还柜子了，被唤醒 */
    }
  }
}

好的，我先查一下天气。

<|DSML|tool_calls>
  <|DSML|invoke name="get_weather">
    <|DSML|parameter name="city">Beijing</parameter>
  </invoke>
</tool_calls>

func ProcessChunk(state *State, chunk string,
    toolNames []string) []Event {
  if chunk != "" { state.pending.WriteString(chunk) }
  events := make([]Event, 0, 2)
  for {
    if state.capturing {
      state.capture.WriteString(state.pending.String())
      state.pending.Reset()
      prefix, calls, suffix, ready := consumeToolCapture(state, toolNames)
      if !ready { break }  // 还没收完整，挂着等下一 chunk
      state.capturing = false
      if len(calls) > 0 {
        if prefix != "" { events = append(events, Event{Content: prefix}) }
        state.pendingToolCalls = calls
      }
      continue
    }
    pending := state.pending.String()
    start := findToolSegmentStart(state, pending)
    if start >= 0 {
      // 切捕获，前缀文本先吐出
      state.capturing = true
    } else {
      // 安全字符：直接吐到客户端
      events = append(events, Event{Content: pending})
    }
  }
  return events
}

// Package pow 提供 DeepSeekHashV1 纯 Go 实现。
// DeepSeekHashV1 = SHA3-256 但跳过 Keccak-f[1600] round 0
// (只做 rounds 1..23)。

func keccakF23(s *[25]uint64) {
  // 标准 Keccak-f[1600] 是 24 轮（0..23），
  // 这里从 r=1 开始，等于跳过第 0 轮。
  for r := 1; r < 24; r++ {
    ...
  }
}

func SolvePow(ctx context.Context, challengeHex, salt string,
    expireAt, difficulty int64) (int64, error) {
  prefix := []byte(BuildPrefix(salt, expireAt))
  // 把 prefix 预吸收进 Keccak 状态，循环里零分配
  var baseState [25]uint64
  // ... prefix 吸收逻辑 ...

  for n := int64(0); n < difficulty; n++ {
    if n&0x3FF == 0 {
      if err := ctx.Err(); err != nil { return 0, err }
    }
    s := baseState
    // 把当前 nonce 写进 numBuf，吸收进 s，跑 keccakF23
    // 比较输出前 32 字节是否等于 challenge
  }
}

async function handler(req, res) {
  setCorsHeaders(res, req);
  if (req.method === 'OPTIONS') { res.statusCode = 204; res.end(); return; }
  const rawBody = await readRawBody(req);

  // 非 Vercel 环境一律转发给 Go
  if (!isVercelRuntime()) {
    await proxyToGo(req, res, rawBody); return;
  }
  const payload = JSON.parse(rawBody.toString('utf8'));

  // 非流式 / 非 OpenAI chat 路径 → 也丢给 Go
  if (!toBool(payload.stream) || !isNodeStreamSupportedPath(req.url)) {
    await proxyToGo(req, res, rawBody); return;
  }
  await handleVercelStream(req, res, rawBody, payload);
}