@miphamai/cli 0.85.5 → 0.85.6

package/src/providers/anthropic.ts

@@ -132,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) {
@@ -153,162 +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 = ''
+          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
               }
-              break
-            }
 
-            case 'content_block_delta': {
-              const delta = event.delta
-              if (!delta) continue
+              case 'content_block_delta': {
+                const delta = event.delta
+                if (!delta) continue
 
-              if (delta.type === 'text_delta' && delta.text) {
-                yield { type: 'text', content: delta.text }
-              }
+                if (delta.type === 'text_delta' && delta.text) {
+                  yield { type: 'text', content: delta.text }
+                }
 
-              if (delta.type === 'thinking_delta' && delta.text) {
-                yield { type: 'thinking', thinking: delta.text }
-              }
+                if (delta.type === 'thinking_delta' && delta.text) {
+                  yield { type: 'thinking', thinking: delta.text }
+                }
 
-              if (delta.type === 'input_json_delta' && delta.partial_json) {
-                accumulatedToolInput += delta.partial_json
+                if (delta.type === 'input_json_delta' && delta.partial_json) {
+                  accumulatedToolInput += delta.partial_json
+                }
+                break
               }
-              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) {
-                // 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: {
+              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',
-                      id: currentToolId,
-                      name: currentToolName,
-                      input: parsedInput,
-                    },
+                      toolUse: {
+                        type: 'tool_use',
+                        id: currentToolId,
+                        name: currentToolName,
+                        input: parsedInput,
+                      },
+                    }
                   }
-                }
 
-                // Reset accumulator
-                currentToolName = ''
-                currentToolId = ''
-                accumulatedToolInput = ''
+                  // Reset accumulator
+                  currentToolName = ''
+                  currentToolId = ''
+                  accumulatedToolInput = ''
+                }
+                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 '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
               }
-              // 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
-            }
 
-            case 'message_stop': {
-              sawTerminalEvent = true
-              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
         }
       }
-    }
 
-    // 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
+      // 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' }
+      yield truncated ? { type: 'stop', truncated: true } : { type: 'stop' }
+    } finally {
+      await reader.cancel().catch(() => {})
+    }
   }
 
   async listModels(): Promise<ModelInfo[]> {

package/src/providers/fetch-utils.ts

@@ -96,7 +96,13 @@ 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 })
@@ -123,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).
     }
   }
 
@@ -163,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
-}

package/src/providers/openai-compat.ts

@@ -38,6 +38,10 @@ export class OpenAICompatProvider implements ProviderInstance {
         Authorization: `Bearer ${apiKey}`,
       },
       body: JSON.stringify(body),
+      // The caller's cancellation (e.g. `self-critique`'s 2s budget) has to reach
+      // the transport, or it is a no-op: `fetch-utils` only combines a caller
+      // signal when this field exists.
+      signal: req.signal,
     })
 
     if (!response.ok) {
@@ -63,136 +67,147 @@ export class OpenAICompatProvider implements ProviderInstance {
     // (DeepSeek V4 / reasoning models) 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`,
+    // The read loop and the fallback 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 {
+          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)
-        if (data === '[DONE]') {
-          // Emit any pending tool calls before stopping
-          for (const [, tc] of pendingToolCalls) {
-            if (!tc.name) continue // drop malformed tool call (missing name)
-            yield {
-              type: 'tool_use',
-              toolUse: {
+                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)
+          if (data === '[DONE]') {
+            // Emit any pending tool calls before stopping
+            for (const [, tc] of pendingToolCalls) {
+              if (!tc.name) continue // drop malformed tool call (missing name)
+              yield {
                 type: 'tool_use',
-                id: tc.id || `call_${Date.now()}`,
-                name: tc.name,
-                input: this.safeParseJson(tc.arguments),
-              },
+                toolUse: {
+                  type: 'tool_use',
+                  id: tc.id || `call_${Date.now()}`,
+                  name: tc.name,
+                  input: this.safeParseJson(tc.arguments),
+                },
+              }
             }
+            yield { type: 'stop', reasoning_content: reasoningContent }
+            return
           }
-          yield { type: 'stop', reasoning_content: reasoningContent }
-          return
-        }
 
-        try {
-          const parsed = JSON.parse(data)
-          const choice = parsed.choices?.[0]
-
-          // Capture token usage when available (final chunk with stream_options.include_usage)
-          if (parsed.usage) {
-            yield {
-              type: 'usage',
-              inputTokens: parsed.usage.prompt_tokens,
-              outputTokens: parsed.usage.completion_tokens,
+          try {
+            const parsed = JSON.parse(data)
+            const choice = parsed.choices?.[0]
+
+            // Capture token usage when available (final chunk with stream_options.include_usage)
+            if (parsed.usage) {
+              yield {
+                type: 'usage',
+                inputTokens: parsed.usage.prompt_tokens,
+                outputTokens: parsed.usage.completion_tokens,
+              }
             }
-          }
 
-          if (!choice) continue
+            if (!choice) continue
 
-          const delta = choice.delta
+            const delta = choice.delta
 
-          if (delta?.tool_calls) {
-            for (const tc of delta.tool_calls) {
-              const idx = tc.index ?? 0
-              const pending = pendingToolCalls.get(idx) || {
-                id: '',
-                name: '',
-                arguments: '',
-              }
+            if (delta?.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                const idx = tc.index ?? 0
+                const pending = pendingToolCalls.get(idx) || {
+                  id: '',
+                  name: '',
+                  arguments: '',
+                }
 
-              if (tc.id) pending.id = tc.id
-              if (tc.function?.name) pending.name = tc.function.name
-              if (tc.function?.arguments) pending.arguments += tc.function.arguments
+                if (tc.id) pending.id = tc.id
+                if (tc.function?.name) pending.name = tc.function.name
+                if (tc.function?.arguments) pending.arguments += tc.function.arguments
 
-              pendingToolCalls.set(idx, pending)
+                pendingToolCalls.set(idx, pending)
+              }
             }
-          }
 
-          if (delta?.content) {
-            yield { type: 'text', content: delta.content }
-          }
+            if (delta?.content) {
+              yield { type: 'text', content: delta.content }
+            }
 
-          if (delta?.reasoning_content) {
-            reasoningContent += delta.reasoning_content
-          }
+            if (delta?.reasoning_content) {
+              reasoningContent += delta.reasoning_content
+            }
 
-          if (choice.finish_reason === 'tool_calls') {
-            // Emit fully accumulated tool calls
-            for (const [, tc] of pendingToolCalls) {
-              if (!tc.name) continue // drop malformed tool call (missing name)
-              yield {
-                type: 'tool_use',
-                toolUse: {
+            if (choice.finish_reason === 'tool_calls') {
+              // Emit fully accumulated tool calls
+              for (const [, tc] of pendingToolCalls) {
+                if (!tc.name) continue // drop malformed tool call (missing name)
+                yield {
                   type: 'tool_use',
-                  id: tc.id || `call_${Date.now()}`,
-                  name: tc.name,
-                  input: this.safeParseJson(tc.arguments),
-                },
+                  toolUse: {
+                    type: 'tool_use',
+                    id: tc.id || `call_${Date.now()}`,
+                    name: tc.name,
+                    input: this.safeParseJson(tc.arguments),
+                  },
+                }
               }
+              pendingToolCalls.clear()
             }
-            pendingToolCalls.clear()
-          }
 
-          if (choice.finish_reason === 'stop') {
-            yield { type: 'stop', reasoning_content: reasoningContent }
-          }
+            if (choice.finish_reason === 'stop') {
+              yield { type: 'stop', reasoning_content: reasoningContent }
+            }
 
-          if (choice.finish_reason === 'length') {
-            // Truncated: the accumulated tool calls were cut off mid-arguments, so
-            // their JSON is incomplete. Drop them rather than dispatching a broken
-            // call, and clear the map so the `[DONE]` handler can't emit them either.
-            pendingToolCalls.clear()
-            yield { type: 'stop', reasoning_content: reasoningContent, truncated: true }
+            if (choice.finish_reason === 'length') {
+              // Truncated: the accumulated tool calls were cut off mid-arguments, so
+              // their JSON is incomplete. Drop them rather than dispatching a broken
+              // call, and clear the map so the `[DONE]` handler can't emit them either.
+              pendingToolCalls.clear()
+              yield { type: 'stop', reasoning_content: reasoningContent, truncated: true }
+            }
+          } catch {
+            // skip unparseable chunks
           }
-        } catch {
-          // skip unparseable chunks
         }
       }
-    }
 
-    yield { type: 'stop', reasoning_content: reasoningContent }
+      yield { type: 'stop', reasoning_content: reasoningContent }
+    } finally {
+      await reader.cancel().catch(() => {})
+    }
   }
 
   async listModels(): Promise<ModelInfo[]> {