@miphamai/cli 0.85.5 → 0.85.7

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[]> {

package/src/shared/arg-validation.ts

@@ -47,6 +47,8 @@ const KNOWN_FLAGS = [
   '--safe-mode',
   '--resume',
   '--permission',
+  '--provider',
+  '--model',
 ]
 
 /**
@@ -60,8 +62,16 @@ const KNOWN_FLAGS = [
  * `--permission` is here for the same reason and for one more: `mipham attach <id>
  * --permission plan` reads the session id through `firstPositional`, and without this
  * entry it would have taken `plan` for a session id.
+ *
+ * `--provider`/`--model` are the same defect a third time, and here it was *measured*
+ * rather than reasoned about: both shipped IDE integrations build
+ * `mipham --provider <id> --model <id>` from their settings (`infrastructure/vscode/
+ * extension.js`, `MiphamAction.kt`), and that command was answered with
+ * `Unknown command: mipham deepseek` — the provider *value* blamed, the flag that was
+ * actually wrong never mentioned, exit 1, no CLI. Their values are open (a provider may
+ * be user-defined), so — unlike `--permission` — this module owns only their spelling.
  */
-const VALUE_FLAGS = ['--resume', '--permission']
+const VALUE_FLAGS = ['--resume', '--permission', '--provider', '--model']
 
 /**
  * The first token that would be read as a command, skipping flags and the values

package/src/shared/package-info.ts

@@ -9,7 +9,7 @@
 export const PACKAGE_NAME = '@miphamai/cli' as const
 
 /** 当前发布版本 */
-export const PACKAGE_VERSION = '0.85.5' as const
+export const PACKAGE_VERSION = '0.85.7' as const
 
 /** npm install 全局安装命令 */
 export const NPM_INSTALL_COMMAND = `npm install -g ${PACKAGE_NAME}` as const
@@ -56,3 +56,38 @@ export const COMPANY_NAME_ZH = '北京华安麦逄科技有限公司' as const
 
 /** 公司简称 */
 export const COMPANY_SHORT = '华安麦逄科技' as const
+
+/**
+ * 计数类常量 —— 公开面（两个官网的产品页）与文档消费的那几个数。
+ *
+ * **不要手改。** 这四个数由 `apps/cli/scripts/sync-counts.ts` 从真源产出后回写：
+ * 命令 / 提供商 / 工具在**进程内算出**（`getCommandNames()` / `DEFAULT_PROVIDERS` /
+ * `createToolRegistry()`），测试数由**一次真套件跑**的自报总数产出。
+ *
+ * 为什么要有这几个槽位（2026-09-25）：两个官网的产品页把「137 命令 · 3473 测试」
+ * 当**字面量**写死，没有真源 ⇒ 只能靠人记得去改，同一处**至少手改过 7 次**
+ * （2262 → … → 3473），而每次手改本身还会再漂。站点侧的传播链其实一直存在 ——
+ * 两站的 deploy 脚本都 `cp` 本文件覆盖自己那份 `src/config/package-info.json`
+ * —— 缺的只是**槽位**。名字/版本有槽位所以不漂，计数连槽位都没有。
+ *
+ * 守卫：`apps/cli/test/integrity/published-counts.test.ts`（三个进程内计数与落盘值
+ * 逐一对齐）；测试总数另由 CI 的 Test job 与套件自报的总数比对（硬门禁）。
+ */
+
+/** Slash 命令总数（真源：`getCommandNames().length`，`apps/cli/src/ui/commands.ts`） */
+export const SLASH_COMMAND_COUNT = 137 as const
+
+/** 内置提供商总数（真源：`DEFAULT_PROVIDERS.length`，`apps/cli/src/shared/constants.ts`） */
+export const PROVIDER_COUNT = 12 as const
+
+/** 已注册工具总数（真源：`createToolRegistry().size`，`apps/cli/src/tools/index.ts`） */
+export const TOOL_COUNT = 31 as const
+
+/**
+ * 测试总数（真源：**一次真套件跑**的自报总数）。
+ *
+ * 取**总数**而不是 `passed`：本机（macOS）与 CI（Linux）的 passed/skipped 切分**不同**
+ * —— `test/e2e/full-pipeline.test.ts` 在 Linux 上整文件 skip、在 macOS 上跑 ——
+ * 但**总数相同**（两边都把被 skip 的算进去）。
+ */
+export const TEST_COUNT = 3535 as const