pi-ccswitch-auto-switch 0.3.12 → 0.3.14

package/README.md

@@ -96,7 +96,7 @@ pi-ccswitch-run --no-tools --no-context-files @prompt.md "Summarize the attached
 
 The runner starts one `pi --mode rpc --no-session --no-extensions --extension <this package>/index.ts` process, so only CCSwitch is loaded. `PI_BIN` may point to the real Pi executable. For migration safety, an old `PI_BIN=pi-ccswitch-run` or `PI_BIN=ccswitch-run` value emits a warning and falls back to `pi` on `PATH` instead of recursing or terminating every downstream job. Arbitrary commands are still rejected. The default deadline is ten minutes and can be changed with `--timeout-ms`.
 
-Exit codes are `0` for success, `1` when candidates are exhausted, `2` for invocation/RPC configuration failures, `124` for timeout, and `130`/`143` for interruption. Text `@files` are supported in the first release; images and stdin input are intentionally not.
+Exit codes are `0` for success, `1` when candidates are exhausted, `2` for invocation/RPC configuration failures, `124` for timeout, and `130`/`143` for interruption. Text and PNG/JPEG/GIF/WebP `@files` are supported. Images are detected by signature and sent as native RPC image parts; invalid image files and other binary formats are rejected. Each attachment is limited to 20 MiB and a request to 20 images. Stdin is not supported.
 
 ## Commands
 
@@ -163,7 +163,7 @@ CCSwitch therefore prechecks **before the request is sent**, instead of waiting
 - Image requirements remain active for the entire failover round, including images returned by tools during retry verification and later fallback attempts;
 - Only models that **explicitly** support images (`input` includes `image`) are considered; models with missing metadata are never assumed to support images;
 - The switch reason is recorded as `modality` and counted in both the session and lifetime switch counters;
-- If no multimodal candidate is available, CCSwitch notifies the user and keeps the current model (Pi will still strip the image and add its notice).
+- If no multimodal candidate is available, RPC image input is handled with an exhausted terminal result before any image-omitted request is sent. Interactive TUI retains its existing notification behavior.
 
 The modality precheck applies only in interactive TUI/RPC sessions (the same scope as failover); print/json modes only monitor and never switch.
 
@@ -183,6 +183,20 @@ npm test
 
 TypeScript is an explicit development dependency. `npm test` enables Node’s native TypeScript stripping and runs all `health`, `integration`, `logic`, and `runner` suites on Node 22.19+. Tests use Node's built-in test runner and cover the failure matrix, family-level policy avoidance, provider-first selection, input compatibility, cooldowns, state persistence, and Windows-compatible paths.
 
+## Optional task complexity
+
+`--task-complexity auto` estimates reasoning effort from the task instruction, input text length,
+and image count. Short text uses low; structured summaries or images use medium; at least
+20,000 characters, 4 images, or cross-source synthesis uses high. This is a deterministic estimate,
+not a model-quality ranking. `low|medium|high` may also be supplied explicitly.
+The selected model stays on Pi defaults unless CCSwitch needs a healthy/vision fallback.
+Pi clamps thinking to model capabilities. An explicit `--thinking` wins; omitting task-complexity
+preserves existing thinking behavior. The runner does not write global settings.
+RPC image requests with no selectable image-capable model terminate with an exhausted result,
+rather than silently sending an image-omitted text request. Interactive TUI behavior is unchanged.
+
+Large images exceeding 1.5 MiB of base64 use the installed Pi image normalizer before RPC dispatch; originals are never modified. If Pi cannot normalize the image, the runner fails explicitly.
+
 ## License
 
 [MIT](LICENSE)

package/README.zh-CN.md

@@ -90,7 +90,7 @@ cd ~/.pi/agent/npm && npm install pi-ccswitch-auto-switch@latest
 pi-ccswitch-run --no-tools --no-context-files @prompt.md "请总结附件"
 ```
 
-runner 内部只显式加载本扩展并启动一次 Pi RPC；`PI_BIN` 应指定内部真实 `pi`。为兼容旧配置，`PI_BIN=pi-ccswitch-run` 或 `PI_BIN=ccswitch-run` 会输出警告并降级到 `PATH` 中的 `pi`，避免递归和长驻消费方连续失败；其他任意命令仍会被拒绝。默认总超时为 10 分钟，可用 `--timeout-ms` 调整。退出码：成功 `0`、候选耗尽 `1`、参数/RPC 配置错误 `2`、超时 `124`、中断 `130/143`。首版只支持文本 `@文件`，不支持图片和 stdin。
+runner 内部只显式加载本扩展并启动一次 Pi RPC；`PI_BIN` 应指定内部真实 `pi`。为兼容旧配置，`PI_BIN=pi-ccswitch-run` 或 `PI_BIN=ccswitch-run` 会输出警告并降级到 `PATH` 中的 `pi`，避免递归和长驻消费方连续失败；其他任意命令仍会被拒绝。默认总超时为 10 分钟，可用 `--timeout-ms` 调整。退出码：成功 `0`、候选耗尽 `1`、参数/RPC 配置错误 `2`、超时 `124`、中断 `130/143`。支持文本及 PNG/JPEG/GIF/WebP `@文件`，按签名识别图片并传入 RPC images；损坏/不支持的图片及其他二进制附件明确拒绝。单附件上限 20 MiB，最多 20 张图片；不支持 stdin。
 
 正常使用 CC Switch 配置 Provider 即可；本插件不会修改 Pi 模型设置或 CC Switch 数据。
 
@@ -151,7 +151,7 @@ Pi 在把请求发给 Provider 时，会根据当前模型的 `input` 能力静
 - 候选只选**明确声明**支持图片的模型（`input` 含 `image`）；元数据缺失的模型不冒险选择；
 - 图片能力要求贯穿整个故障转移轮次，包括重试验证阶段工具返回图片以及此后的再次切换；
 - 切换原因记为 `modality`，计入本 session 切换数与累计切换；
-- 如果没有可用的多模态候选，则通知用户并保持原模型继续（Pi 会照常剥图并附带提示）。
+- 如果没有可用的多模态候选，RPC 图片输入会返回 exhausted 终态并在发出剥图请求前停止；交互式 TUI 保持原有通知行为。
 
 模态预检只在 TUI/RPC 交互模式下生效（与故障转移一致）；print/json 模式只监控不切换。
 
@@ -171,6 +171,14 @@ npm test
 
 TypeScript 已显式列为开发依赖。`npm test` 开启 Node 原生 TypeScript 类型剥离，在 Node 22.19+ 上运行 `health`、`integration`、`logic`、`runner` 全部测试。测试使用 Node 内置测试运行器，覆盖失败分类矩阵、系列级审查避让、Provider 优先选择、输入兼容、冷却、状态持久化以及 Windows 路径。
 
+## 可选任务复杂度
+
+`--task-complexity auto` 根据任务指令、输入文字长度和图片数量估计推理强度：短文本使用 low；结构化摘要或图片使用 medium；至少 20,000 个字符、4 张图片或跨来源综合分析使用 high。也可显式指定 `low|medium|high`。这是确定性的任务估计，不是模型质量排名。
+
+默认沿用 Pi 当前模型；需要健康或视觉候选时由 CCSwitch 切换。Pi 会按模型能力限制推理强度。显式 `--thinking` 优先；省略 `--task-complexity` 时保留现有推理行为。runner 不写入全局设置。
+
+RPC 图片请求没有可选的视觉模型时返回 exhausted 终态，避免发送丢失图片的请求。交互式 TUI 行为保持不变。超过 1.5 MiB base64 的大图会通过已安装 Pi 的图片处理功能压缩后传入 RPC，保留原图；处理失败时明确报错。
+
 ## 许可证
 
 [MIT](LICENSE)

package/index.ts

@@ -17,7 +17,7 @@ const roundLimitMs = (): number => {
   return Number.isFinite(override) && override > 0 ? override : ROUND_LIMIT_DEFAULT
 }
 const RPC_PROTOCOL_VERSION = 1
-const EXTENSION_VERSION = '0.3.12'
+const EXTENSION_VERSION = '0.3.14'
 // 同端点（BaseURL 相同）连续失败达到该次数即隔离该端点，避免同一个平台的多个模型逐个试错耗尽本轮切换
 const ENDPOINT_FAIL_THRESHOLD = 3
 
@@ -394,6 +394,10 @@ export default function (pi: ExtensionAPI) {
     // 模态预检：输入带图片但当前模型不支持图片（非多模态）→ 主动切换到多模态模型，
     // 避免 Pi 静默剥图后模型只回答“看不到图片”（此类情况不会触发 failover）。
     if (event.images?.length && round.phase === 'monitoring') await proactiveModalitySwitch(ctx, round)
+    if (event.images?.length && ctx.mode === 'rpc' && !round.model?.input?.includes('image')) {
+      await exhaust(ctx, 'image input requires an available image-capable model')
+      return { action: 'handled' }
+    }
     return { action: 'continue' }
   })
   pi.on('before_provider_request', (_event, ctx) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ccswitch-auto-switch",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "Provider-first automatic model failover extension for Pi and CC Switch",
   "license": "MIT",
   "keywords": [

package/runner.mjs

@@ -4,18 +4,20 @@
  * extension retries a failed turn on another model.
  */
 import { spawn } from 'node:child_process'
-import { access, readFile, stat } from 'node:fs/promises'
+import { access, readFile, realpath, stat } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
+import { fileURLToPath, pathToFileURL } from 'node:url'
 import { delimiter, dirname, extname, isAbsolute, join, resolve } from 'node:path'
 
 export const EXIT = Object.freeze({ SUCCESS: 0, EXHAUSTED: 1, CONFIG: 2, TIMEOUT: 124, INTERRUPTED: 130, TERMINATED: 143 })
 export const DEFAULT_TIMEOUT_MS = 600_000
+export const INLINE_IMAGE_MAX_BYTES = 1.5 * 1024 * 1024
 
-const usage = `Usage: pi-ccswitch-run [options] [--] [@text-file ...] <prompt>
+const usage = `Usage: pi-ccswitch-run [options] [--] [@text-or-image-file ...] <prompt>
 
 Options:
   --timeout-ms <ms>       Total runner timeout (default: ${DEFAULT_TIMEOUT_MS})
+  --task-complexity <v>   auto, low, medium, high (omitted: keep Pi thinking)
   --no-tools              Disable Pi tools
   --no-context-files      Disable AGENTS.md / CLAUDE.md discovery
   --provider <name>       Initial Pi provider
@@ -35,11 +37,17 @@ export function parseArgs(argv) {
   const files = []
   const prompt = []
   let timeoutMs = DEFAULT_TIMEOUT_MS
+  let complexity
   let positional = false
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index]
     if (arg === '--') { positional = true; continue }
     if (!positional && (arg === '-h' || arg === '--help')) return { help: true }
+    if (!positional && arg === '--task-complexity') {
+      complexity = argv[++index]
+      if (!['auto', 'low', 'medium', 'high'].includes(complexity)) throw new Error('invalid --task-complexity')
+      continue
+    }
     if (!positional && arg === '--timeout-ms') {
       const raw = argv[++index]
       const value = Number(raw)
@@ -64,7 +72,19 @@ export function parseArgs(argv) {
     prompt.push(arg)
   }
   if (prompt.length === 0) throw new Error('a prompt is required')
-  return { timeoutMs, piArgs, files, prompt: prompt.join(' ') }
+  return { timeoutMs, piArgs, files, prompt: prompt.join(' '), ...(complexity ? { complexity } : {}) }
+}
+
+export function assessComplexity(prompt, fileText = '', imageCount = 0) {
+  const chars = prompt.length + fileText.length
+  // 只根据任务指令、输入规模和图片数量估计；不把附件正文当路由指令。
+  if (chars >= 20000 || imageCount >= 4 || /跨文章|跨聊天|主题脉络|交叉核验|因果分析|多来源|cross.source|synthesi[sz]/i.test(prompt)) {
+    return { level: 'high', reason: 'long-input-or-synthesis' }
+  }
+  if (imageCount || chars >= 2000 || /JSON|结构化|摘要|summari[sz]/i.test(prompt)) {
+    return { level: 'medium', reason: 'structured-or-visual' }
+  }
+  return { level: 'low', reason: 'short-text' }
 }
 
 export async function readTextFiles(fileArgs, cwd = process.cwd()) {
@@ -87,6 +107,60 @@ export function buildMessage(fileText, prompt) {
   return fileText ? `${fileText}\n${prompt}` : prompt
 }
 
+export async function readAttachments(fileArgs, cwd = process.cwd()) {
+  let fileText = ''
+  const images = []
+  for (const raw of fileArgs) {
+    const path = resolve(cwd, raw)
+    const info = await stat(path)
+    if (!info.isFile()) throw new Error(`not a regular file: ${path}`)
+    if (info.size > 20 * 1024 * 1024) throw new Error(`attachment exceeds 20 MiB: ${path}`)
+    const data = await readFile(path)
+    let mimeType
+    if (data.subarray(0, 8).equals(Buffer.from('89504e470d0a1a0a', 'hex'))) mimeType = 'image/png'
+    else if (data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff) mimeType = 'image/jpeg'
+    else if (/^GIF8[79]a$/.test(data.subarray(0, 6).toString('ascii'))) mimeType = 'image/gif'
+    else if (data.subarray(0, 4).toString() === 'RIFF' && data.subarray(8, 12).toString() === 'WEBP') mimeType = 'image/webp'
+    if (mimeType) {
+      if (images.length >= 20) throw new Error('at most 20 image attachments are supported')
+      images.push({ type: 'image', data: data.toString('base64'), mimeType })
+      fileText += `<file name="${path}">Image attachment ${images.length}</file>\n`
+    } else {
+      if (/\.(png|jpe?g|gif|webp|heic|heif|bmp|tiff?)$/i.test(path)) throw new Error(`invalid or unsupported image: ${path}`)
+      fileText += await readTextFiles([path])
+    }
+  }
+  return { fileText, images }
+}
+
+export async function normalizeLargeImages(images, resizeImage) {
+  const maxBytes = INLINE_IMAGE_MAX_BYTES
+  const result = []
+  for (const image of images) {
+    if (image.data.length <= maxBytes) { result.push(image); continue }
+    const resized = await resizeImage(Buffer.from(image.data, 'base64'), image.mimeType, { maxBytes })
+    if (!resized?.data || resized.data.length > maxBytes) throw new Error('image exceeds inline size limit after normalization')
+    result.push({ type: 'image', data: resized.data, mimeType: resized.mimeType })
+  }
+  return result
+}
+
+export async function prepareImages(images, resolvePi = resolvePiCommand) {
+  if (!images.some(image => image.data.length > INLINE_IMAGE_MAX_BYTES)) return images
+  const resolved = await resolvePi()
+  const executable = resolved.prefix[0] || resolved.command
+  const candidates = isAbsolute(executable) ? [executable]
+    : (process.env.PATH || '').split(delimiter).filter(Boolean).map(dir => join(dir, executable))
+  const found = candidates.find(path => existsSync(path))
+  if (!found) throw new Error('cannot locate Pi image normalizer for large attachments')
+  const entry = await realpath(found)
+  const normalizer = [join(dirname(entry), 'utils', 'image-resize.js'), join(dirname(entry), '..', 'utils', 'image-resize.js')]
+    .find(path => existsSync(path))
+  if (!normalizer) throw new Error('installed Pi does not expose image normalization for large attachments')
+  const { resizeImage } = await import(pathToFileURL(normalizer).href)
+  return normalizeLargeImages(images, resizeImage)
+}
+
 const LEGACY_RUNNER_STEMS = new Set(['pi-ccswitch-run', 'ccswitch-run'])
 
 function executableStem(value) {
@@ -242,7 +316,14 @@ export async function run(options, runtime = {}) {
     if (!Array.isArray(commands?.commands) || !commands.commands.some((entry) => entry.name === 'ccswitch')) {
       throw new Error('CCSwitch extension did not load')
     }
-    await request('prompt', { message: options.message })
+    if (options.complexity && !options.piArgs.includes('--thinking')) {
+      const assessment = options.complexity === 'auto'
+        ? assessComplexity(options.prompt || '', options.fileText ?? options.message, options.images?.length || 0)
+        : { level: options.complexity, reason: 'explicit-complexity' }
+      await request('set_thinking_level', { level: assessment.level })
+      log(`complexity=${assessment.level} reason=${assessment.reason} images=${options.images?.length || 0}`)
+    }
+    await request('prompt', { message: options.message, ...(options.images?.length ? { images: options.images } : {}) })
     while (!terminal && !protocolError && !closed) await new Promise(resolveWait => setTimeout(resolveWait, 10))
     if (protocolError) {
       closeStdin()
@@ -282,8 +363,10 @@ export async function main(argv = process.argv.slice(2)) {
   try { options = parseArgs(argv) } catch (error) { process.stderr.write(`pi-ccswitch-run: ${error.message}\n${usage}\n`); return EXIT.CONFIG }
   if (options.help) { process.stdout.write(`${usage}\n`); return EXIT.SUCCESS }
   try {
-    const fileText = await readTextFiles(options.files)
-    const result = await run({ ...options, message: buildMessage(fileText, options.prompt) })
+    const attached = await readAttachments(options.files)
+    const fileText = attached.fileText
+    const images = await prepareImages(attached.images)
+    const result = await run({ ...options, fileText, images, message: buildMessage(fileText, options.prompt) })
     if (result.text) process.stdout.write(`${result.text}\n`)
     if (result.error) process.stderr.write(`pi-ccswitch-run: ${result.error}\n`)
     return result.code
@@ -293,5 +376,6 @@ export async function main(argv = process.argv.slice(2)) {
   }
 }
 
-const invoked = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)
+const invokedPath = process.argv[1] && await realpath(resolve(process.argv[1])).catch(() => undefined)
+const invoked = invokedPath === fileURLToPath(import.meta.url)
 if (invoked) main().then(code => { process.exitCode = code })