@qwen-code/qwen-code 0.16.2 → 0.17.0

package/bundled/qc-helper/docs/configuration/settings.md

@@ -146,7 +146,11 @@ Settings are organized into categories. Most settings should be placed within th
 | `model.maxWallTimeSeconds`                         | number  | Wall-clock budget for headless / unattended runs, in seconds. `-1` means unlimited. Overridable per-invocation via `--max-wall-time`, which requires a positive duration (`90`, `30s`, `5m`, `1h`, `1.5h`); the minimum is 1 second — sub-second values (`500ms`, `0.5`) are rejected as typos. Omit the flag to fall back to this setting. Aborts with exit code 55 when exceeded.                                                                                                                                                                                                                                                                                                                                                                          | `-1`        |
 | `model.maxToolCalls`                               | number  | Cumulative tool-call budget for a run (counts every executed tool, success or failure; `structured_output` under `--json-schema` is exempt). `-1` means unlimited; `0` means "no tool calls allowed". Capped at 1,000,000 to catch typos. Overridable via `--max-tool-calls`. Aborts with exit code 55 when exceeded.                                                                                                                                                                                                                                                                                                                                                                                                                                        | `-1`        |
 | `model.generationConfig`                           | object  | Advanced overrides passed to the underlying content generator. Supports request controls such as `timeout`, `maxRetries`, `enableCacheControl`, `splitToolMedia` (set `true` for strict OpenAI-compatible servers like LM Studio that reject non-text content on `role: "tool"` messages — splits media into a follow-up user message), `contextWindowSize` (override model's context window size), `modalities` (override auto-detected input modalities), `customHeaders` (custom HTTP headers for API requests), and `extra_body` (additional body parameters for OpenAI-compatible API requests only), along with fine-tuning knobs under `samplingParams` (for example `temperature`, `top_p`, `max_tokens`). Leave unset to rely on provider defaults. | `undefined` |
-| `model.chatCompression.contextPercentageThreshold` | number  | **REMOVED.** Auto-compaction now uses a three-tier threshold ladder (warn / auto / hard) computed internally from the model's context window via the `computeThresholds()` function — no longer user-configurable. Setting this field in `settings.json` is silently ignored, and a one-line deprecation warning is emitted to stderr at startup. There is currently no replacement for "disable compression entirely" — reactive overflow recovery remains the safety net at the API layer if compression itself fails. (See PR #4345 / `docs/design/auto-compaction-threshold-redesign.md` for the redesign rationale.)                                                                                                                                    | `N/A`       |
+| `model.chatCompression.contextPercentageThreshold` | number  | **REMOVED.** Auto-compaction now uses a three-tier threshold ladder (warn / auto / hard) computed internally from the model's context window via the `computeThresholds()` function — no longer user-configurable. Setting this field in `settings.json` is silently ignored (no startup warning). There is currently no replacement for "disable compression entirely" — reactive overflow recovery remains the safety net at the API layer if compression itself fails. (See PR #4345 / `docs/design/auto-compaction-threshold-redesign.md` for the redesign rationale.)                                                                                                                                                                                   | `N/A`       |
+| `model.chatCompression.maxRecentFilesToRetain`     | number  | Number of most-recently-touched files whose current content is restored (embedded if small, otherwise referenced by path) into history after auto-compaction. `0` restores none. Env override: `QWEN_COMPACT_MAX_RECENT_FILES`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `5`         |
+| `model.chatCompression.maxRecentImagesToRetain`    | number  | Number of most-recent images (tool screenshots / user pastes) restored into history after auto-compaction. `0` restores none. Env override: `QWEN_COMPACT_MAX_RECENT_IMAGES`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `3`         |
+| `model.chatCompression.enableScreenshotTrigger`    | boolean | When `true`, auto-compaction also fires once the number of tool-returned images accumulated in history reaches `screenshotTriggerThreshold`, independent of token usage — aimed at computer-use sessions where frequent screenshots dilute model attention. Counts only images returned inside tool results, not user-pasted images. Env override: `QWEN_COMPACT_SCREENSHOT_TRIGGER` (`1`/`true`/`0`/`false`).                                                                                                                                                                                                                                                                                                                                               | `true`      |
+| `model.chatCompression.screenshotTriggerThreshold` | number  | Tool-returned image count at or above which the screenshot trigger fires (only when `enableScreenshotTrigger`). Compaction resets the count — surviving images are re-embedded as top-level parts, which the trigger doesn't count — so it won't immediately re-fire. Env override: `QWEN_COMPACT_SCREENSHOT_THRESHOLD`.                                                                                                                                                                                                                                                                                                                                                                                                                                     | `50`        |
 | `model.skipNextSpeakerCheck`                       | boolean | Skip the next speaker check.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `false`     |
 | `model.skipLoopDetection`                          | boolean | Disables streaming loop detection checks. Defaults to `true` (loop detection is skipped) to avoid false positives interrupting legitimate workflows. Set to `false` to re-enable streaming loop detection — useful as a guardrail in headless / non-interactive runs where stuck repetition can otherwise waste budget.                                                                                                                                                                                                                                                                                                                                                                                                                                      | `true`      |
 | `model.skipStartupContext`                         | boolean | Skips sending the startup workspace context (environment summary and acknowledgement) at the beginning of each session. Enable this if you prefer to provide context manually or want to save tokens on startup.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `false`     |

package/bundled/qc-helper/docs/features/channels/_meta.ts

@@ -3,5 +3,6 @@ export default {
   telegram: 'Telegram',
   weixin: 'WeChat',
   dingtalk: 'DingTalk',
+  feishu: 'Feishu',
   plugins: 'Plugins',
 };

package/bundled/qc-helper/docs/features/channels/feishu.md

@@ -0,0 +1,170 @@
+# Feishu (Lark)
+
+This guide covers setting up a Qwen Code channel on Feishu (飞书) / Lark.
+
+## Prerequisites
+
+- A Feishu organization account
+- A Feishu application with App ID and App Secret (see below)
+
+## Creating an Application
+
+1. Go to the [Feishu Open Platform](https://open.feishu.cn)
+2. Create a new application (or use an existing one)
+3. Under the application, enable the **Bot** capability (添加应用能力 → 机器人)
+4. In **Event Subscriptions** (事件与回调), select **Long Connection** (使用长连接接收事件)
+5. Add the event `im.message.receive_v1` (接收消息)
+6. Note the **App ID** (Client ID) and **App Secret** (Client Secret) from the application credentials page
+
+### Required Permissions
+
+Enable the following permissions under **Permissions & Scopes** (权限管理):
+
+- `im:message` — Read and send messages
+- `im:message:send_as_bot` — Send messages as bot
+- `im:resource` — Access message resources (images, files)
+
+### Publish the Application
+
+After configuring permissions and events, create a version and publish it. The bot won't work until the application is published and approved.
+
+## Configuration
+
+Add the channel to `~/.qwen/settings.json`:
+
+```json
+{
+  "channels": {
+    "my-feishu": {
+      "type": "feishu",
+      "clientId": "<your-app-id>",
+      "clientSecret": "<your-app-secret>",
+      "senderPolicy": "open",
+      "sessionScope": "user",
+      "cwd": "/path/to/your/project",
+      "groupPolicy": "open",
+      "collapsible": true,
+      "groups": {
+        "*": { "requireMention": true }
+      }
+    }
+  }
+}
+```
+
+### Configuration Options
+
+| Option                 | Description                                                         |
+| ---------------------- | ------------------------------------------------------------------- |
+| `clientId`             | Feishu App ID                                                       |
+| `clientSecret`         | Feishu App Secret                                                   |
+| `collapsible`          | Collapse long responses into expandable sections (default: `false`) |
+| `collapsibleThreshold` | Character threshold for collapsing (default: `500`)                 |
+| `webhookPort`          | If set, use HTTP webhook mode instead of WebSocket                  |
+| `verificationToken`    | Verification token for webhook mode                                 |
+| `encryptKey`           | Encrypt key for webhook mode                                        |
+
+## Running
+
+```bash
+# Start only the Feishu channel
+qwen channel start my-feishu
+
+# Or start all configured channels together
+qwen channel start
+```
+
+Open Feishu and send a message to the bot. You should see a streaming interactive card with the response.
+
+## Connection Modes
+
+### WebSocket (Default)
+
+WebSocket mode uses an outbound long connection — no public URL or server is needed. This is the recommended mode for most deployments.
+
+### Webhook
+
+If you need webhook mode (e.g., for shared applications), set `webhookPort` in your config:
+
+```json
+{
+  "channels": {
+    "my-feishu": {
+      "type": "feishu",
+      "webhookPort": 9321,
+      "verificationToken": "<from-feishu-console>",
+      "encryptKey": "<from-feishu-console>"
+    }
+  }
+}
+```
+
+Then set the request URL in Feishu Open Platform to `http://<your-server>:9321`.
+
+## Group Chats
+
+Feishu bots work in both DM and group conversations. To enable group support:
+
+1. Set `groupPolicy` to `"allowlist"` or `"open"` in your channel config
+2. Add the bot to a Feishu group
+3. @mention the bot in the group to trigger a response
+
+By default, the bot requires an @mention in group chats (`requireMention: true`). Set `"requireMention": false` for a specific group to make it respond to all messages.
+
+## Features
+
+### Interactive Card Streaming
+
+Responses are rendered as Feishu interactive cards with real-time streaming updates. The card shows a "generating" indicator while the response is being produced, and a **Stop** button to cancel generation.
+
+### Quote/Reply Context
+
+When you reply to (quote) a message, the quoted content is automatically included as context for the agent. This works for:
+
+- Text and rich-text messages
+- Interactive cards (bot's previous responses)
+
+### Images and Files
+
+You can send photos and documents to the bot:
+
+- **Images:** Analyzed using multimodal vision capabilities
+- **Files:** Downloaded and saved locally for the agent to read
+
+### Concurrent Messages
+
+Multiple users can send messages simultaneously in the same group chat. Each message gets its own independent card and response — they don't interfere with each other.
+
+## Key Differences from DingTalk
+
+- **Response format:** Uses Feishu interactive cards (v2 schema) with native markdown rendering, including tables
+- **Streaming:** Card content is updated in-place with throttled PATCH requests (1.5s interval)
+- **Connection:** WebSocket via `@larksuiteoapi/node-sdk` — same outbound-only model, no public URL needed
+- **Working indicator:** An "OnIt" emoji reaction is added while processing
+- **Quote context:** Supports quoting both text messages and interactive cards
+
+## Troubleshooting
+
+### Bot doesn't connect
+
+- Verify your App ID and App Secret are correct
+- Make sure **Long Connection** is selected in Event Subscriptions
+- Check that the `im.message.receive_v1` event is subscribed
+- Check the terminal output for connection errors
+
+### Bot doesn't respond in groups
+
+- Check that `groupPolicy` is set to `"allowlist"` or `"open"` (default is `"disabled"`)
+- Make sure you @mention the bot in the group message
+- Verify the bot has been added to the group
+
+### Card stays in "generating" state
+
+- This usually indicates the response completed but the final card update failed
+- Check terminal logs for API errors (rate limiting, card size limits)
+- Very long responses with many tables may hit Feishu's card element limits
+
+### Quote doesn't include card content
+
+- The bot reads card content via the `card_msg_content_type=user_card_content` API parameter
+- Ensure the bot has `im:message` permission to read messages

package/chunks/{agent-RY5EB3XR.js → agent-KVXFGIOU.js}

@@ -7,31 +7,36 @@ import {
   hasRebuiltToolRegistry,
   rebuildToolRegistryOnOverride,
   resolveSubagentApprovalMode
-} from "./chunk-7HM6OB7M.js";
-import "./chunk-K5PGHDBN.js";
+} from "./chunk-7EHPK6TK.js";
+import "./chunk-24YKA2DA.js";
 import "./chunk-O4PICXES.js";
 import "./chunk-TW522KN6.js";
+import "./chunk-TI4GXJKO.js";
+import "./chunk-AKBFRR6J.js";
 import "./chunk-MLZQVCF3.js";
-import "./chunk-C27V5A2J.js";
+import "./chunk-EMVEDSVZ.js";
 import "./chunk-EY6BDW7Y.js";
-import "./chunk-K72FHBFO.js";
+import "./chunk-HAQCNXSG.js";
 import "./chunk-77WXWU44.js";
 import "./chunk-GVWPJCXU.js";
-import "./chunk-JVD46YJV.js";
-import "./chunk-4YNZFYJY.js";
+import "./chunk-MEN6IEKX.js";
+import "./chunk-J5VCSWPA.js";
 import "./chunk-UWCTAVOD.js";
+import "./chunk-W57YDFU5.js";
 import "./chunk-OFEVLU4C.js";
 import "./chunk-NQ3E7YLD.js";
-import "./chunk-6NUSWV4M.js";
 import "./chunk-ODPVJ6JJ.js";
-import "./chunk-T4VD6OJ4.js";
-import "./chunk-RDYWTWEM.js";
-import "./chunk-FO7BIVSR.js";
-import "./chunk-YMDXEEOW.js";
+import "./chunk-UQRYJQBE.js";
+import "./chunk-6RQTH7UQ.js";
+import "./chunk-R2B65CAN.js";
 import "./chunk-7YJIR2FX.js";
 import "./chunk-OIL7KDWV.js";
+import "./chunk-U2K6HDUJ.js";
+import "./chunk-6NUSWV4M.js";
+import "./chunk-HCSJIOLR.js";
+import "./chunk-SZOEIL6S.js";
+import "./chunk-5IFG2VC4.js";
 import "./chunk-ACBGEKB7.js";
-import "./chunk-E7E2MFYM.js";
 import "./chunk-ZERZSAZL.js";
 import "./chunk-QN5NZ3UQ.js";
 import "./chunk-BR4QREVK.js";

package/chunks/{anthropicContentGenerator-LYI3OHBB.js → anthropicContentGenerator-L4HWAOIV.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-KQIKOTQJ.js";
 import {
   RequestTokenizer
-} from "./chunk-VMOWXTRC.js";
+} from "./chunk-V7LMZR76.js";
 import {
   Blob,
   File,
@@ -16,7 +16,7 @@ import {
 import {
   buildRuntimeFetchOptions,
   redactProxyError
-} from "./chunk-JVD46YJV.js";
+} from "./chunk-U2K6HDUJ.js";
 import {
   CAPPED_DEFAULT_MAX_TOKENS,
   DEFAULT_TIMEOUT,
@@ -29,12 +29,12 @@ import {
 import {
   FinishReason,
   GenerateContentResponse
-} from "./chunk-T4VD6OJ4.js";
-import "./chunk-RDYWTWEM.js";
+} from "./chunk-HCSJIOLR.js";
+import "./chunk-SZOEIL6S.js";
+import "./chunk-5IFG2VC4.js";
 import {
   createDebugLogger
 } from "./chunk-ACBGEKB7.js";
-import "./chunk-E7E2MFYM.js";
 import {
   require_ms
 } from "./chunk-BR4QREVK.js";

package/chunks/{askUserQuestion-R3MKD2JT.js → askUserQuestion-DC6OWQIL.js}

@@ -2,11 +2,13 @@
 "use strict";
 import "./chunk-MLZQVCF3.js";
 import {
-  BaseDeclarativeTool,
-  BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-YMDXEEOW.js";
+} from "./chunk-6RQTH7UQ.js";
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation
+} from "./chunk-R2B65CAN.js";
 import {
   createDebugLogger
 } from "./chunk-ACBGEKB7.js";

package/chunks/chunk-24YKA2DA.js

@@ -0,0 +1,233 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  BRAND,
+  DIRTY,
+  EMPTY_PATH,
+  INVALID,
+  NEVER,
+  OK,
+  ParseStatus,
+  ZodAny,
+  ZodArray,
+  ZodBigInt,
+  ZodBoolean,
+  ZodBranded,
+  ZodCatch,
+  ZodDate,
+  ZodDefault,
+  ZodDiscriminatedUnion,
+  ZodEffects,
+  ZodEnum,
+  ZodError,
+  ZodFirstPartyTypeKind,
+  ZodFunction,
+  ZodIntersection,
+  ZodIssueCode,
+  ZodLazy,
+  ZodLiteral,
+  ZodMap,
+  ZodNaN,
+  ZodNativeEnum,
+  ZodNever,
+  ZodNull,
+  ZodNullable,
+  ZodNumber,
+  ZodObject,
+  ZodOptional,
+  ZodParsedType,
+  ZodPipeline,
+  ZodPromise,
+  ZodReadonly,
+  ZodRecord,
+  ZodSet,
+  ZodString,
+  ZodSymbol,
+  ZodTuple,
+  ZodType,
+  ZodUndefined,
+  ZodUnion,
+  ZodUnknown,
+  ZodVoid,
+  addIssueToContext,
+  anyType,
+  arrayType,
+  bigIntType,
+  booleanType,
+  coerce,
+  custom,
+  dateType,
+  datetimeRegex,
+  discriminatedUnionType,
+  effectsType,
+  en_default,
+  enumType,
+  functionType,
+  getErrorMap,
+  getParsedType,
+  instanceOfType,
+  intersectionType,
+  isAborted,
+  isAsync,
+  isDirty,
+  isValid,
+  late,
+  lazyType,
+  literalType,
+  makeIssue,
+  mapType,
+  nanType,
+  nativeEnumType,
+  neverType,
+  nullType,
+  nullableType,
+  numberType,
+  objectType,
+  objectUtil,
+  oboolean,
+  onumber,
+  optionalType,
+  ostring,
+  pipelineType,
+  preprocessType,
+  promiseType,
+  quotelessJson,
+  recordType,
+  setErrorMap,
+  setType,
+  strictObjectType,
+  stringType,
+  symbolType,
+  tupleType,
+  undefinedType,
+  unionType,
+  unknownType,
+  util,
+  voidType
+} from "./chunk-AKBFRR6J.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __export
+} from "./chunk-J2S4EL5Y.js";
+
+// node_modules/zod/v3/external.js
+var external_exports = {};
+__export(external_exports, {
+  BRAND: () => BRAND,
+  DIRTY: () => DIRTY,
+  EMPTY_PATH: () => EMPTY_PATH,
+  INVALID: () => INVALID,
+  NEVER: () => NEVER,
+  OK: () => OK,
+  ParseStatus: () => ParseStatus,
+  Schema: () => ZodType,
+  ZodAny: () => ZodAny,
+  ZodArray: () => ZodArray,
+  ZodBigInt: () => ZodBigInt,
+  ZodBoolean: () => ZodBoolean,
+  ZodBranded: () => ZodBranded,
+  ZodCatch: () => ZodCatch,
+  ZodDate: () => ZodDate,
+  ZodDefault: () => ZodDefault,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodEffects: () => ZodEffects,
+  ZodEnum: () => ZodEnum,
+  ZodError: () => ZodError,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodFunction: () => ZodFunction,
+  ZodIntersection: () => ZodIntersection,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodLazy: () => ZodLazy,
+  ZodLiteral: () => ZodLiteral,
+  ZodMap: () => ZodMap,
+  ZodNaN: () => ZodNaN,
+  ZodNativeEnum: () => ZodNativeEnum,
+  ZodNever: () => ZodNever,
+  ZodNull: () => ZodNull,
+  ZodNullable: () => ZodNullable,
+  ZodNumber: () => ZodNumber,
+  ZodObject: () => ZodObject,
+  ZodOptional: () => ZodOptional,
+  ZodParsedType: () => ZodParsedType,
+  ZodPipeline: () => ZodPipeline,
+  ZodPromise: () => ZodPromise,
+  ZodReadonly: () => ZodReadonly,
+  ZodRecord: () => ZodRecord,
+  ZodSchema: () => ZodType,
+  ZodSet: () => ZodSet,
+  ZodString: () => ZodString,
+  ZodSymbol: () => ZodSymbol,
+  ZodTransformer: () => ZodEffects,
+  ZodTuple: () => ZodTuple,
+  ZodType: () => ZodType,
+  ZodUndefined: () => ZodUndefined,
+  ZodUnion: () => ZodUnion,
+  ZodUnknown: () => ZodUnknown,
+  ZodVoid: () => ZodVoid,
+  addIssueToContext: () => addIssueToContext,
+  any: () => anyType,
+  array: () => arrayType,
+  bigint: () => bigIntType,
+  boolean: () => booleanType,
+  coerce: () => coerce,
+  custom: () => custom,
+  date: () => dateType,
+  datetimeRegex: () => datetimeRegex,
+  defaultErrorMap: () => en_default,
+  discriminatedUnion: () => discriminatedUnionType,
+  effect: () => effectsType,
+  enum: () => enumType,
+  function: () => functionType,
+  getErrorMap: () => getErrorMap,
+  getParsedType: () => getParsedType,
+  instanceof: () => instanceOfType,
+  intersection: () => intersectionType,
+  isAborted: () => isAborted,
+  isAsync: () => isAsync,
+  isDirty: () => isDirty,
+  isValid: () => isValid,
+  late: () => late,
+  lazy: () => lazyType,
+  literal: () => literalType,
+  makeIssue: () => makeIssue,
+  map: () => mapType,
+  nan: () => nanType,
+  nativeEnum: () => nativeEnumType,
+  never: () => neverType,
+  null: () => nullType,
+  nullable: () => nullableType,
+  number: () => numberType,
+  object: () => objectType,
+  objectUtil: () => objectUtil,
+  oboolean: () => oboolean,
+  onumber: () => onumber,
+  optional: () => optionalType,
+  ostring: () => ostring,
+  pipeline: () => pipelineType,
+  preprocess: () => preprocessType,
+  promise: () => promiseType,
+  quotelessJson: () => quotelessJson,
+  record: () => recordType,
+  set: () => setType,
+  setErrorMap: () => setErrorMap,
+  strictObject: () => strictObjectType,
+  string: () => stringType,
+  symbol: () => symbolType,
+  transformer: () => effectsType,
+  tuple: () => tupleType,
+  undefined: () => undefinedType,
+  union: () => unionType,
+  unknown: () => unknownType,
+  util: () => util,
+  void: () => voidType
+});
+init_esbuild_shims();
+
+// node_modules/zod/index.js
+init_esbuild_shims();
+
+export {
+  external_exports
+};

package/chunks/{chunk-UFC57OYT.js → chunk-33RDTIU6.js}

@@ -1,9 +1,11 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  external_exports,
-  external_exports2
-} from "./chunk-K5PGHDBN.js";
+  external_exports
+} from "./chunk-24YKA2DA.js";
+import {
+  external_exports as external_exports2
+} from "./chunk-AKBFRR6J.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-C6WMLUNB.js → chunk-3BJBCG2K.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getGlobalQwenDir
-} from "./chunk-USE2VQ5P.js";
+} from "./chunk-NP3ICQCN.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";