@miphamai/cli 0.85.4 → 0.85.6

package/src/providers/anthropic.ts

@@ -78,6 +78,15 @@ export class AnthropicProvider implements ProviderInstance {
     // off at the output ceiling rather than ended by the model.
     let truncated = false
 
+    // Whether this stream reached `message_stop`. A stream that runs out without
+    // one was cut — a proxy or gateway closing the connection cleanly looks
+    // exactly like a finished response otherwise.
+    let sawTerminalEvent = false
+
+    // Tool blocks already emitted. A replayed event is the same call, not a
+    // second one; emitting it twice makes the engine run the tool twice.
+    const emittedToolIds = new Set<string>()
+
     const messages = this.convertMessages(req.messages)
     this.markPrefixCacheBreakpoint(messages)
 
@@ -123,6 +132,9 @@ export class AnthropicProvider implements ProviderInstance {
         'anthropic-beta': 'prompt-caching-2024-07-31',
       },
       body: JSON.stringify(body),
+      // Same as `openai-compat`: without this the caller's signal never reaches
+      // the transport, and every per-call cancellation budget is decorative.
+      signal: req.signal,
     })
 
     if (!response.ok) {
@@ -144,150 +156,173 @@ export class AnthropicProvider implements ProviderInstance {
     // passes aren't mistaken for a stalled connection.
     const STREAM_READ_TIMEOUT_MS = streamIdleTimeoutMs(req.effort)
 
-    while (true) {
-      let readResult: Awaited<ReturnType<typeof reader.read>>
-      let idleTimer: ReturnType<typeof setTimeout> | undefined
-      try {
-        readResult = await Promise.race([
-          reader.read(),
-          new Promise<never>((_, reject) => {
-            idleTimer = setTimeout(
-              () =>
-                reject(
-                  new Error(
-                    `Stream read timeout — no data for ${Math.round(STREAM_READ_TIMEOUT_MS / 1000)}s`,
-                  ),
-                ),
-              STREAM_READ_TIMEOUT_MS,
-            )
-          }),
-        ])
-      } catch (err) {
-        yield { type: 'error', error: `Stream stalled: ${String(err)}` }
-        return
-      } finally {
-        if (idleTimer) clearTimeout(idleTimer)
-      }
-      const { done, value } = readResult
-      if (done) break
-
-      buffer += decoder.decode(value, { stream: true })
-      const lines = buffer.split('\n')
-      buffer = lines.pop() || ''
-
-      for (const line of lines) {
-        const trimmed = line.trim()
-        if (!trimmed || !trimmed.startsWith('data: ')) continue
-        const data = trimmed.slice(6)
-
+    // The read loop and the trailing stop share one reader, and that reader owns
+    // the connection. `engine.ts` breaks out of this generator on the ordinary
+    // `stop` chunk, and a sub-agent throws mid-stream on abort — both call
+    // `.return()`, which unwinds through here. Without this, a turn that ends
+    // normally (or is abandoned) leaves the body unread and uncancelled, so the
+    // socket can't be reused. `cancel()` on an already-errored stream rejects, and
+    // on a closed one is a no-op — the catch covers the first.
+    try {
+      while (true) {
+        let readResult: Awaited<ReturnType<typeof reader.read>>
+        let idleTimer: ReturnType<typeof setTimeout> | undefined
         try {
-          const event = JSON.parse(data) as AnthropicSSEEvent
-
-          switch (event.type) {
-            case 'content_block_start': {
-              const cb = event.content_block
-              if (!cb) continue
-
-              if (cb.type === 'tool_use') {
-                currentToolName = cb.name || ''
-                currentToolId = cb.id || ''
-                accumulatedToolInput = ''
-              }
-              break
-            }
-
-            case 'content_block_delta': {
-              const delta = event.delta
-              if (!delta) continue
-
-              if (delta.type === 'text_delta' && delta.text) {
-                yield { type: 'text', content: delta.text }
+          readResult = await Promise.race([
+            reader.read(),
+            new Promise<never>((_, reject) => {
+              idleTimer = setTimeout(
+                () =>
+                  reject(
+                    new Error(
+                      `Stream read timeout — no data for ${Math.round(STREAM_READ_TIMEOUT_MS / 1000)}s`,
+                    ),
+                  ),
+                STREAM_READ_TIMEOUT_MS,
+              )
+            }),
+          ])
+        } catch (err) {
+          yield { type: 'error', error: `Stream stalled: ${String(err)}` }
+          return
+        } finally {
+          if (idleTimer) clearTimeout(idleTimer)
+        }
+        const { done, value } = readResult
+        if (done) break
+
+        buffer += decoder.decode(value, { stream: true })
+        const lines = buffer.split('\n')
+        buffer = lines.pop() || ''
+
+        for (const line of lines) {
+          const trimmed = line.trim()
+          if (!trimmed || !trimmed.startsWith('data: ')) continue
+          const data = trimmed.slice(6)
+
+          try {
+            const event = JSON.parse(data) as AnthropicSSEEvent
+
+            switch (event.type) {
+              case 'content_block_start': {
+                const cb = event.content_block
+                if (!cb) continue
+
+                if (cb.type === 'tool_use') {
+                  currentToolName = cb.name || ''
+                  currentToolId = cb.id || ''
+                  accumulatedToolInput = ''
+                }
+                break
               }
 
-              if (delta.type === 'thinking_delta' && delta.text) {
-                yield { type: 'thinking', thinking: delta.text }
-              }
+              case 'content_block_delta': {
+                const delta = event.delta
+                if (!delta) continue
 
-              if (delta.type === 'input_json_delta' && delta.partial_json) {
-                accumulatedToolInput += delta.partial_json
-              }
-              break
-            }
-
-            case 'content_block_stop': {
-              // 此刻还无从得知本轮是否被截断 —— `stop_reason` 要到后面的
-              // `message_delta` 才到（见下方同名分支）。所以被截断的 `tool_use`
-              // 在这里已经发出去了；openai-compat 那条路上「截断即丢弃未完成的
-              // tool_call」的处置，这里结构上做不到（它的 finish_reason 与
-              // tool_calls 落在同一个响应体里）。**这是有意的不对称，不是漏做**：
-              // 要在这里丢弃，就得把 `tool_use` 缓冲到 `message_stop` 再发 ——
-              // 那是一次行为变更，不属本次范围。
-              if (currentToolId && currentToolName && accumulatedToolInput) {
-                let parsedInput: Record<string, unknown> = {}
-                try {
-                  parsedInput = JSON.parse(accumulatedToolInput)
-                } catch {
-                  parsedInput = { _raw: accumulatedToolInput }
+                if (delta.type === 'text_delta' && delta.text) {
+                  yield { type: 'text', content: delta.text }
                 }
 
-                yield {
-                  type: 'tool_use',
-                  toolUse: {
-                    type: 'tool_use',
-                    id: currentToolId,
-                    name: currentToolName,
-                    input: parsedInput,
-                  },
+                if (delta.type === 'thinking_delta' && delta.text) {
+                  yield { type: 'thinking', thinking: delta.text }
                 }
 
-                // Reset accumulator
-                currentToolName = ''
-                currentToolId = ''
-                accumulatedToolInput = ''
+                if (delta.type === 'input_json_delta' && delta.partial_json) {
+                  accumulatedToolInput += delta.partial_json
+                }
+                break
               }
-              break
-            }
 
-            case 'message_delta': {
-              // Capture token usage for accurate cost tracking
-              if (event.usage) {
-                yield {
-                  type: 'usage',
-                  inputTokens: event.usage.input_tokens,
-                  outputTokens: event.usage.output_tokens,
+              case 'content_block_stop': {
+                // 此刻还无从得知本轮是否被截断 —— `stop_reason` 要到后面的
+                // `message_delta` 才到（见下方同名分支）。所以被截断的 `tool_use`
+                // 在这里已经发出去了；openai-compat 那条路上「截断即丢弃未完成的
+                // tool_call」的处置，这里结构上做不到（它的 finish_reason 与
+                // tool_calls 落在同一个响应体里）。**这是有意的不对称，不是漏做**：
+                // 要在这里丢弃，就得把 `tool_use` 缓冲到 `message_stop` 再发 ——
+                // 那是一次行为变更，不属本次范围。
+                if (currentToolId && currentToolName && accumulatedToolInput) {
+                  // A replayed block carries the id it was first sent with, so the
+                  // id is what tells a second call apart from the same call twice.
+                  if (!emittedToolIds.has(currentToolId)) {
+                    emittedToolIds.add(currentToolId)
+
+                    let parsedInput: Record<string, unknown> = {}
+                    try {
+                      parsedInput = JSON.parse(accumulatedToolInput)
+                    } catch {
+                      parsedInput = { _raw: accumulatedToolInput }
+                    }
+
+                    yield {
+                      type: 'tool_use',
+                      toolUse: {
+                        type: 'tool_use',
+                        id: currentToolId,
+                        name: currentToolName,
+                        input: parsedInput,
+                      },
+                    }
+                  }
+
+                  // Reset accumulator
+                  currentToolName = ''
+                  currentToolId = ''
+                  accumulatedToolInput = ''
                 }
+                break
               }
-              // Contains stop_reason; also handles late input_json_delta
-              if (event.delta?.type === 'input_json_delta' && event.delta.partial_json) {
-                accumulatedToolInput += event.delta.partial_json
-              }
-              // `max_tokens` means the turn hit the output ceiling. Without this the
-              // truncation is indistinguishable from `end_turn`: both arrive here and
-              // the terminal stop below looks the same either way.
-              const stopReason = event.delta?.stop_reason
-              if (stopReason === 'max_tokens') {
-                truncated = true
+
+              case 'message_delta': {
+                // Capture token usage for accurate cost tracking
+                if (event.usage) {
+                  yield {
+                    type: 'usage',
+                    inputTokens: event.usage.input_tokens,
+                    outputTokens: event.usage.output_tokens,
+                  }
+                }
+                // Contains stop_reason; also handles late input_json_delta
+                if (event.delta?.type === 'input_json_delta' && event.delta.partial_json) {
+                  accumulatedToolInput += event.delta.partial_json
+                }
+                // `max_tokens` means the turn hit the output ceiling. Without this the
+                // truncation is indistinguishable from `end_turn`: both arrive here and
+                // the terminal stop below looks the same either way.
+                const stopReason = event.delta?.stop_reason
+                if (stopReason === 'max_tokens') {
+                  truncated = true
+                }
+                break
               }
-              break
-            }
 
-            case 'message_stop': {
-              yield truncated ? { type: 'stop', truncated: true } : { type: 'stop' }
-              return
-            }
+              case 'message_stop': {
+                sawTerminalEvent = true
+                yield truncated ? { type: 'stop', truncated: true } : { type: 'stop' }
+                return
+              }
 
-            case 'error': {
-              yield { type: 'error', error: event.error?.message || 'Unknown Anthropic error' }
-              return
+              case 'error': {
+                yield { type: 'error', error: event.error?.message || 'Unknown Anthropic error' }
+                return
+              }
             }
+          } catch {
+            // Skip unparseable SSE events
           }
-        } catch {
-          // Skip unparseable SSE events
         }
       }
-    }
 
-    yield { type: 'stop' }
+      // The stream ran out without `message_stop`. Whatever stopped it, the turn is
+      // incomplete — and this is the only place that knows, because a cleanly
+      // closed connection and a finished response are otherwise the same stream.
+      if (!sawTerminalEvent) truncated = true
+
+      yield truncated ? { type: 'stop', truncated: true } : { type: 'stop' }
+    } finally {
+      await reader.cancel().catch(() => {})
+    }
   }
 
   async listModels(): Promise<ModelInfo[]> {

package/src/providers/fetch-utils.ts

@@ -16,6 +16,58 @@ export interface FetchWithRetryOptions {
 
 const RETRYABLE_STATUSES = new Set([429, 500, 502, 503, 504])
 
+/**
+ * Upper bound on a server-supplied `Retry-After`, in ms.
+ *
+ * The header is a *request*, not a contract: a 5xx answering `Retry-After: 3600`
+ * used to park the CLI in `sleep` for a full hour with nothing on screen. The
+ * user cannot cancel what they cannot see, so the wait is capped and the reason
+ * is left in the comment rather than the terminal.
+ */
+export const RETRY_AFTER_MAX_MS = 60_000
+
+/**
+ * Lower bound on a server-supplied `Retry-After`, in ms.
+ *
+ * `Retry-After: 0` is a real thing servers send, and honouring it literally
+ * means retrying the instant the previous attempt failed — a hammering loop
+ * dressed up as politeness. Any present-but-tiny value lands here instead.
+ */
+const RETRY_AFTER_MIN_MS = 1_000
+
+/**
+ * Delay before the next retry attempt.
+ *
+ * `Retry-After` is honoured when it is parseable, clamped to
+ * `[RETRY_AFTER_MIN_MS, RETRY_AFTER_MAX_MS]`, and **ignored in favour of
+ * exponential backoff when it is not** — an unparseable header must not become
+ * `sleep(NaN)`, which `setTimeout` reads as 0 (the same back-to-back retry as
+ * `Retry-After: 0`, but silent).
+ *
+ * Accepts both RFC 9110 forms: delta-seconds and an HTTP-date.
+ */
+export function retryDelayMs(
+  retryAfter: string | null,
+  attempt: number,
+  baseDelay: number,
+): number {
+  const backoff = baseDelay * Math.pow(2, attempt)
+  if (retryAfter === null) return backoff
+
+  const header = retryAfter.trim()
+  const seconds = parseInt(header, 10)
+  let requested: number
+  if (!Number.isNaN(seconds)) {
+    requested = seconds * 1000
+  } else {
+    const at = Date.parse(header)
+    if (Number.isNaN(at)) return backoff // unparseable → backoff, never a zero sleep
+    requested = at - Date.now()
+  }
+
+  return Math.min(Math.max(requested, RETRY_AFTER_MIN_MS), RETRY_AFTER_MAX_MS)
+}
+
 function isRetryableError(err: unknown): boolean {
   if (err instanceof DOMException && err.name === 'AbortError') return false
   return true
@@ -44,18 +96,20 @@ export async function fetchWithRetry(
       timedOut = true
       controller.abort()
     }, timeout)
-    const signal = init.signal ? anySignal([init.signal, controller.signal]) : controller.signal
+    // `AbortSignal.any` (node ≥22 / bun ≥1.2, both in `engines`) instead of a
+    // hand-rolled combiner: it keeps a *weak* reference to the source signals, so
+    // the combination stays live for the reader without pinning the caller's
+    // signal — which is what the hand-rolled version had to trade away.
+    const signal = init.signal
+      ? AbortSignal.any([init.signal, controller.signal])
+      : controller.signal
 
     try {
       const response = await fetch(url, { ...init, signal })
 
       // 429 / 5xx → retry
       if (RETRYABLE_STATUSES.has(response.status) && attempt < maxRetries) {
-        const retryAfter = response.headers.get('Retry-After')
-        const delay = retryAfter
-          ? parseInt(retryAfter, 10) * 1000
-          : baseDelay * Math.pow(2, attempt)
-        await sleep(delay)
+        await sleep(retryDelayMs(response.headers.get('Retry-After'), attempt, baseDelay))
         continue
       }
 
@@ -75,14 +129,11 @@ export async function fetchWithRetry(
       await sleep(baseDelay * Math.pow(2, attempt))
     } finally {
       clearTimeout(timer)
-      // Clean up combined signal if we created one
-      if (init.signal) {
-        try {
-          controller.abort()
-        } catch {
-          /* best effort */
-        }
-      }
+      // Nothing to release: the combination is natively managed. Do NOT abort
+      // anything here — `fetch` holds that signal and the caller reads the body
+      // *after* we return, so aborting it at this point errored every response at
+      // the headers (measured on Node: the next read throws AbortError; Bun
+      // happens to tolerate it, which is why a Bun-only run never showed this).
     }
   }
 
@@ -115,23 +166,3 @@ export function streamIdleTimeoutMs(effort?: string): number {
   const multiplier = effort ? (EFFORT_TIMEOUT_MULTIPLIER[effort] ?? 1) : 1
   return STREAM_IDLE_TIMEOUT_BASE_MS * multiplier
 }
-
-/**
- * Combine multiple AbortSignals into one — any signal aborting
- * triggers the combined signal.
- */
-function anySignal(signals: AbortSignal[]): AbortSignal {
-  const controller = new AbortController()
-  const onAbort = () => {
-    controller.abort()
-    for (const s of signals) s.removeEventListener('abort', onAbort)
-  }
-  for (const s of signals) {
-    if (s.aborted) {
-      controller.abort()
-      return controller.signal
-    }
-    s.addEventListener('abort', onAbort)
-  }
-  return controller.signal
-}