dsh-packycode-api 1.4.4 → 1.4.6

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 1.4.6
+
+- **Hy4 joins the catalog.** PackyCode added the `hunyuan-officially` group (腾讯混元官方渠道) and Tencent's `hy4` model: on 2026-11-04 `/api/pricing` lists `hy4` in that group alone, with `anthropic`, `openai` and `openai-response` endpoints. `hy4` takes the Responses route: `openai-responses` at `https://cf.api.fan/v1`, text and image input, 1,024,000 context and 64,000 output. TokenHub's [Hunyuan guide](https://cloud.tencent.com/document/product/1823/132252) gives Hy4 a 1024K context, of which at most 960K input, 64K output and image input on all three protocols, and its [model overview](https://cloud.tencent.com/document/product/1823/130079) marks Hy4's Responses support as native rather than converted. The gateway does not check `max_output_tokens` (1,000,000 was accepted), so the output ceiling is the documented 64K, read as 64,000 like DeepSeek's 384K. Hy4 sits after Grok 4.7 in the picker, and the settings panel counts it on a Hunyuan line under each key.
+- **Its efforts are `off` and `high`.** TokenHub's [deep thinking page](https://cloud.tencent.com/document/product/1823/131208) lists `reasoning_effort` `high` and `no_think` for Hy4, with thinking on by default. `high` is sent as is, and `off` sends `reasoning.effort: "no_think"`, the value Hy4's own row names. pi-ai's default `none` answered the same, and TokenHub's [Responses compatibility page](https://cloud.tencent.com/document/product/1823/133813) accepts both. The gateway also accepts `minimal`, `low`, `medium`, `xhigh` and `max`, but Hy4 does not document them and did not answer them differently from `high`, so they are not offered. Session titles run on Hy4 itself at `off`, the least effort it offers.
+- **Reasoning, caching and tools.** Reasoning streams as `response.reasoning_summary_text.delta` into `summary_text` items, which pi-ai shows as thinking and replays unchanged with the turn's tool calls and in later turns, as TokenHub's [preserved thinking](https://cloud.tencent.com/document/product/1823/133534) asks for Hy4. The prefix cache hits as often without `prompt_cache_key` as with it, so Hy4 is sent none, like DeepSeek. Tools go without `strict`: TokenHub documents a function tool's `strict` as defaulting to true, but Hy4 filled DSH's optional sandbox fields about as rarely with `strict` omitted as with `strict: false`.
+- **Hy4 is told who made it.** DSH's system prompt opens with "You are an AI agent powered by DeepSeek Harness." and "You are a coding agent powered by the hy4 model.": it names the harness, and the model only by its id. In the desktop app Hy4 then said it was a DeepSeek model, and asked whether it was Hunyuan, it denied it and claimed `hy` did not stand for Hunyuan. Every Hy4 request now ends its leading instructions with one sentence (`src/hy4-identity.js`): the hy4 model is Hy4 from Tencent Hunyuan, reached through PackyCode, and DeepSeek Harness is the agent app it runs in, not its model or its maker. DSH's text stays as written, and the sentence never changes, so the cached prefix stays stable; a caller's own payload hook still sees the final body. No other model's request changes: under DSH's prompt with their own ids, GPT-6.1 Sol and Terra named OpenAI, Grok 4.7 xAI, Gemini 3.8 Flash Google, and DeepSeek Flash and V4 Pro DeepSeek.
+- Validation, 2026-11-04:
+  - **Offline:** 557 tests (new: Hy4's catalog entry, efforts, wire dialect and resolved metadata; `high` sent without the cache key or `strict`; `off` sent as `no_think`; summary reasoning streamed as thinking and replayed unchanged with its tool call and in the next user turn; undocumented efforts refused through the route before any request; Hy4 titling its own sessions at `off`; an image reaching Responses through DSH's `LlmRuntime`; pricing and coverage for `hunyuan-officially`; the identity sentence appended once after DSH's instructions, or sent alone without them, ahead of a caller's payload hook, and absent from the other models' requests), both rebuilt bundles and the versioned tarball. The suite also passed on Node 22.23.1.
+  - **Live, direct to `/v1/responses` with the test key (`hunyuan-officially` among its groups):** with no effort the gateway echoed `high`. `no_think` and `none` both answered with no reasoning item and 4 output tokens, at 52 prompt tokens against 49 for every thinking level, and a made-up effort was refused with 400. On one arithmetic problem, four requests per level all had 69 prompt tokens, and mean reasoning tokens were 4,160 at `low`, 2,917 at `medium`, 4,117 at `high`, 3,823 at `xhigh` and 3,506 at `max`, against a spread of 1,270–7,737 within the levels. With DSH's bash tool, the optional sandbox pair was filled in 1 of 14 calls with `strict` omitted, 1 of 14 with `strict: false` and 0 of 14 with `strict: true`. A prefix of about 13,000 tokens sent 8 times was cached on 4 of the 7 repeats both with and without `prompt_cache_key`.
+  - **Live, through the built route:** `off` sent `no_think` and answered `ok` without thinking, and `high` answered `ok` with streamed thinking; `minimal`, `low`, `medium`, `xhigh` and `max` were refused before any request. An `echo` tool call continued to `ok` 2 of 2 times at `high` and 2 of 2 at `off`, replaying the reasoning item and the `fc_` call item, and a following user turn carried every earlier reasoning item and answered with the echoed text, 4 of 4. DSH's title request at `off` came back as 整理十月发货单并标缺货. `scripts/live-check.mjs --model hy4 --with-vision` answered `ok` and named a red and a blue image. With the identity sentence in place, the efforts, 3 more `echo` continuations and the title came back the same; the vision check named both images in 1 of 3 runs, and in the other two Hy4 reasoned past the script's 2,048-token output cap at `high` on the red image and was cut off without an answer. Sent directly with the same image, 5 of 10 requests without the sentence and 4 of 10 with it ended at that cap, so the sentence is not the cause; DSH's own requests use the model's 64,000-token ceiling. In the full `scripts/live-check.mjs`, the key's groups read as reaching Hy4 and every model answered except `gemini-4-argon`: `/api/pricing` now lists Argon only in `gemini-officially`, which the test key lacks, and the gateway refused it with `分组 gemini-slb 下模型 gemini-4-argon 无可用渠道（distributor）`. That is upstream, and nothing in this change touches Gemini. Key rotation, the rejected-key classification, both auto reviewers and the RPC projections were unchanged. Not checked in the desktop app.
+  - **Live, Hy4's identity:** the desktop session's log showed both answers coming from `packycode / hy4` in Hy4's own reply format. Sent directly without a system prompt, Hy4 answered "我是混元，是由腾讯开发的大模型" 3 of 3 times. With DSH's system prompt it named DeepSeek Harness or no maker at all, never Tencent, in 3 of 3; after the desktop session's first answer it denied being Hunyuan 6 of 6 times; with the harness renamed it no longer claimed DeepSeek. With the sentence, sent directly with DSH's prompt, it named Tencent Hunyuan in 4 of 4 first answers, confirmed being Hunyuan in 4 of 4 follow-ups and named Tencent in 4 of 4 English answers; through the built route, 3 of 3 for each turn. The sentence did not leak into other answers: `ok` 3 of 3, a JavaScript question 3 of 3 and DSH titles 3 of 3 carried no identity talk, and a bare 你好 introduced itself as Tencent Hunyuan's Hy4 in 2 of 3. Not checked in the desktop app.
+
+## 1.4.5
+
+- **Diagnostics now say how a request to PackyCode failed on the network.** An Ubuntu user running `dsh --profile web` saw model requests retried over and over: one session had 39 failed attempts in 12 steps, logged as `Request timed out.`, a later one `Connection error.`, and the balance read `fetch failed (ETIMEDOUT)` from every status host. Each attempt failed about 0.5 s after it started. `cf.api.fan` and `www.packyapi.ai` resolve to two IPv4 and two IPv6 addresses. Node tries them in turn and gives every address but the last 250 ms (`net.getDefaultAutoSelectFamilyAttemptTimeout()`). On that machine the lookup returned the IPv6 addresses but they could not be reached, so the last address failed at once, and the connection failed whenever both IPv4 handshakes took longer than 250 ms. Node's own undici reports that as an `AggregateError`, which the OpenAI SDK calls `Connection error.`. The undici 8 that DSH installs with a proxy policy rewrites it as a `ConnectTimeoutError` that still says `timeout: 10000ms`, which the SDK calls `Request timed out.`. The report kept neither the cause nor the addresses, so the two texts looked like two problems.
+- **The report has a `network` section** (`src/network.js`). From the moment the plugin loads, it listens on undici's `diagnostics_channel` for requests to the plugin's own hosts: `cf.api.fan`, `www.packyapi.ai`, `www.packyapi.com` and any host override. For each host it records requests, answered requests by status, failures by stage (connect, request or mid-response), cancellations, time to response headers, and connections that needed a later address or went over IPv6. Each of the 12 latest failures keeps the path without its query, its stage and duration, the error chain's names and codes, each address tried with its error, and the message, redacted and shortened. The section also gives the Node version and platform, `autoSelectFamily`, the per-address attempt timeout, the DNS result order and the scheme each proxy variable names. It looks each host up the way `net.connect` does, waiting at most 3 s. Headers, bodies, queries, proxy addresses and other hosts are never read. The section covers the whole process rather than one session, and the card's privacy note and both READMEs say so.
+- Validation, 2026-10-30:
+  - **Offline:** 544 tests (new: requests to a loopback server counted by status and timed, and another host name for the same server ignored; a connection refused on both addresses of a host recorded with each address; a cancellation counted apart from failures, a timeout recorded at the request stage and a cut body mid-response; undici 8's rewritten connect timeout and a connection that needed a later address read from published events, with stored keys redacted and only the newest failures kept; proxy schemes without proxy hosts or credentials; host lookups bounded at 3 s; the plugin's own wiring through the RPC), both rebuilt bundles and the versioned tarball.
+  - **Under DSH's runtime (the desktop app's Node 24.21 with its undici 8.11.2):** one host resolved to two IPv4 addresses that never answered and two IPv6 addresses that refused at once. The connection failed after 510–525 ms. Through Node's undici the log recorded `AggregateError ETIMEDOUT`; through DSH's undici 8 it recorded `ConnectTimeoutError UND_ERR_CONNECT_TIMEOUT` over `AggregateError ETIMEDOUT`. Both records listed the four addresses with their codes. On real traffic to `cf.api.fan` (its root path, no key), direct and through a local HTTP proxy with DSH's undici 8, the log counted three requests answered 404, their time to headers and their connections. Going direct, one of the two connections reached the second address after the first took longer than 250 ms. The built `lib/index.js` loads there. Not checked in the desktop app or on Linux.
+- **Gemini 4 Argon is back in the catalog.** PackyCode serves `gemini-4-argon` again: on 2026-10-30 `/api/pricing` lists it in `gemini-slb` and `gemini-officially`, and the gateway answers it. It takes back its earlier entry: `google-generative-ai` at `https://cf.api.fan/v1beta`, 1,048,576 context and 65,536 output per Google's model page, and `low`, `medium` and `high`. The pricing page now lists an `openai` endpoint for it too; it stays on the native protocol with Flash, with `thinkingLevel` and the skip signature, and the one resend stays Flash's alone. The picker offers twelve models, the settings panel counts Argon under Gemini, `scripts/gemini-tool-check.mjs` takes it again, and the READMEs' FAQ entry about the refusal is gone. A session left on Argon works again without being changed.
+- Validation, 2026-10-30:
+  - **Offline:** 548 tests (the per-model native Gemini tests run for Argon again, its catalog entry, efforts and resolved metadata are pinned again, the replay guard's non-Flash case is Argon again, and a session on a model that left the catalog is still refused as `UNKNOWN_MODEL` before any credential is read), both rebuilt bundles and the versioned tarball.
+  - **Live, through the built route, with the test key (`gemini-slb` among its groups):** Argon answered in `scripts/live-check.mjs`, named a red and a blue image, and read as reached by the key's groups. Native tool calls continued to `ok` in 6 of 10 rounds (4 at `low`, 1 at `medium`, 1 at `high`), each continuation accepted on its first send, with no signature refusal. Of the other four, three passed the script's 90 s limit without finishing, and one was refused at 08:24Z with `分组 gemini-slb 下模型 gemini-4-argon 无可用渠道（distributor）`. Flash continued a tool call to `ok` once at `low`. The other models answered, except `grok-4.7`: `/api/pricing` now lists it only in `grok-sale`, which the test key lacks, and the gateway refused it with `分组 grok-officially 下模型 grok-4.7 无可用渠道（distributor）`. That is upstream, and nothing in the plugin changed for it. Not checked in the desktop app.
+  - **Live, direct to the native endpoint:** the stalls are not Argon's alone. Sampled every 20 s from 08:25Z to 08:31Z, Argon answered 15 of 16 requests in 3.8–64 s and Flash 12 of 16 in 2.0–11.6 s; the rest of each passed 90 s. In a run of 12 streaming requests per model, all 24 answered, with headers after 2.8–51 s on Argon and 2.0–10.6 s on Flash.
+
 ## 1.4.4
 
 - **DeepSeek V4 Pro joins the catalog** ([#4](https://github.com/BaronCyrus/dsh-packycode-api/issues/4)). `deepseek-v4-pro` takes DeepSeek Flash's route: `openai-responses` at `https://cf.api.fan/v1`, 1,000,000 context and 384,000 output, with Flash's efforts (`off` as `reasoning.effort: "none"`, `low`, `high`, `max`), per DeepSeek's [models and pricing page](https://api-docs.deepseek.com/quick_start/pricing/) and [API reference](https://api-docs.deepseek.com/api/create-chat-completion). PackyCode's `/api/pricing` lists it in `deepseek-officially` and `deepseek-sale` with `openai-response` among its endpoints, at 4.5 times Flash's input rate. It sits after Flash in the picker, and the settings panel counts it under DeepSeek. pi-ai's own DeepSeek catalog pins `low` unsupported for V4 Pro; DeepSeek documents `low` for both models, and through PackyCode V4 Pro answered it as its own level.

package/README.en.md

@@ -48,10 +48,10 @@ You need **DeepSeek Harness** and a **PackyCode (PackyAPI) API key**. For DSH se
 Open the desktop application's **Plugins** page, click **Add plugin**, and enter the package name **with a version** as the **package name or address**:
 
 ```text
-dsh-packycode-api@1.4.4
+dsh-packycode-api@1.4.6
 ```
 
-Choose the **official** install source, then click **Install**. `1.4.4` was the latest release when this was written; the [npm page](https://www.npmjs.com/package/dsh-packycode-api) shows the current one.
+Choose the **official** install source, then click **Install**. `1.4.6` was the latest release when this was written; the [npm page](https://www.npmjs.com/package/dsh-packycode-api) shows the current one.
 
 > **Always include the version.** With a bare `dsh-packycode-api`, the install prompt shows the newest version on npm, but DSH's bundled pnpm by default installs only versions published at least 24 hours ago, so you can end up several releases behind with no sign of it in the prompt. With an exact version, pnpm installs that version and adds it to the profile's `minimumReleaseAgeExclude` itself. Afterwards, check **Current version** under **Settings → PackyCode → Plugin version**.
 
@@ -65,14 +65,14 @@ Open **Settings → PackyCode**. Paste the API key under **Add a key**. A label
 
 ### 3. Select a model
 
-Choose a model from the `PackyCode` group. Of the eleven models, Claude runs through this device's Claude Code CLI on `cc` keys; everything else uses the plugin’s HTTP route. Your key’s groups must cover the selected model.
+Choose a model from the `PackyCode` group. Of the thirteen models, Claude runs through this device's Claude Code CLI on `cc` keys; everything else uses the plugin’s HTTP route. Your key’s groups must cover the selected model.
 
 <details>
 <summary>Verify the install / other profiles / a local checkout</summary>
 
 The **Plugins** page shows the installed state and version, and is also where you enable, disable, or uninstall.
 
-**For non-desktop profiles only:** `dsh plugin --profile <name> add dsh-packycode-api@1.4.4`. Do not use it for `desktop` — the CLI refuses it (`profile "desktop" is managed exclusively by the Electron application`).
+**For non-desktop profiles only:** `dsh plugin --profile <name> add dsh-packycode-api@1.4.6`. Do not use it for `desktop` — the CLI refuses it (`profile "desktop" is managed exclusively by the Electron application`).
 
 For a local checkout, keep the `link:` prefix: `dsh plugin --profile <name> add link:/path/to/dsh-packycode-api`. **Do not pass a bare path or `file:`** — that install copies the whole checkout, `node_modules` included, into the profile, where it then shadows the packages the DSH installation itself provides and the plugin looks uninstalled; see the FAQ. If you already installed that way, uninstall first and reinstall as above.
 
@@ -86,7 +86,7 @@ A profile without a browser can still use the model route. It just has no settin
 
 **Switch keys.** Keys are used in the order they were added. **Use this key** picks the preferred key, effective from the next turn; **Rename** changes its label (at most 60 characters, empty names are refused); **Re-enable** puts a disabled key back after a top-up or replacement.
 
-**See groups.** Under **Accounts and keys**, each key lists its PackyCode groups (hover for the group's description) and which models they reach: ✓ yes, ◐ partly, ✕ no. The groups come from the gateway itself (its refusal of a model id it cannot route names the token's groups, as “已选分组=[…]”, or for a single-group key as “分组 … 下模型 … 无可用渠道”; nothing is billed), matched against PackyCode's public model-group table. Check Claude group coverage per model; do not assume `cc-sale` serves all three models; GPT needs `codex` / `codex-sale`; DeepSeek needs `deepseek-officially` / `deepseek-sale`.
+**See groups.** Under **Accounts and keys**, each key lists its PackyCode groups (hover for the group's description) and which models they reach: ✓ yes, ◐ partly, ✕ no. The groups come from the gateway itself (its refusal of a model id it cannot route names the token's groups, as “已选分组=[…]”, or for a single-group key as “分组 … 下模型 … 无可用渠道”; nothing is billed), matched against PackyCode's public model-group table. Check Claude group coverage per model; do not assume `cc-sale` serves all three models; GPT needs `codex` / `codex-sale`; DeepSeek needs `deepseek-officially` / `deepseek-sale`; Hy4 needs `hunyuan-officially`.
 
 **Read the balance.** Each key under **Accounts and keys** shows its own remaining, used, and limit (limit = remaining + used); an unlimited key shows **No quota limit**. Keys are not added up into a total. An API key can read only its own quota, not the PackyCode account's balance, so check the account balance in the PackyCode console. A key that could not be read says why on its own row; a key whose read failed this time but succeeded before keeps showing its last balance with the time it was read (the composer shows it as `≈US$…`) until DSH restarts. The composer shows the active key's remaining balance only while a PackyCode model is selected. **Refresh** bypasses the roughly 60-second cache. The default model host is `https://cf.api.fan` and the balance host is `https://www.packyapi.ai`; both can be changed under **Advanced: endpoints**. The old default, `https://www.packyapi.com`, is DNS-poisoned on mainland networks and answers `fetch failed` without a proxy; even when settings still name it, `.ai` is tried first.
 
@@ -227,6 +227,8 @@ The card shows whether DSH's plugin is on, how many reviews this plugin answered
 | `gpt-6-astra` | Same | Cannot be off; `low` / `medium` / `high` / `xhigh` / `max` | Same |
 | `gpt-5.6-sol` | Same | Same | Same |
 | `grok-4.7` (Grok 4.7) | HTTP, Responses, text/image input; 500K context | Cannot be off; `low` / `medium` / `high` / `xhigh` | The Grok coverage read from the gateway in Settings |
+| `hy4` (Hy4, Tencent Hunyuan) | HTTP, Responses, text/image input; 1024K context (at most 960K input), 64K output | Can be off; `high` only | `hunyuan-officially` |
+| `gemini-4-argon` (Gemini 4 Argon) | HTTP, native Gemini streaming, text/image input; 1,048,576 context, 65,536 output | Cannot be off; `low` / `medium` / `high` | `gemini-slb` |
 | `gemini-3.8-flash` (Gemini 3.8 Flash) | HTTP, native Gemini streaming, text/image input; 1,048,576 input, 65,536 output | Cannot be off; `low` / `medium` / `high` | `gemini-slb` |
 | `claude-opus-5-5` | Anthropic Messages, images and native tools: this device's Claude Code CLI as the agent for `cc` keys, HTTP otherwise | Cannot be off; `low` / `medium` / `high` / `xhigh` / `max` | Claude-group coverage reported in Settings |
 | `claude-sonnet-5-5` | Same | Same | Same |
@@ -236,15 +238,17 @@ A model in the list does not mean the current token group allows it. When changi
 
 `jev-latest` (TypeSafe Jev) is not in the model picker: it is a decision model that answers classification questions and cannot hold a conversation, so it only serves [Auto review](#auto-review). The plugin calls `/v1/systemone` host-side; it needs a key in the `typesafe-officially` group, and each key's Jev entry under Accounts and keys shows whether it can.
 
-Of the eleven models in the current catalog, all but DeepSeek V4 Pro declare text and image input. DeepSeek Flash follows the [official vision guide](https://api-docs.deepseek.com/guides/vision/); images are read through DSH's attachment service and sent with the Responses request. DeepSeek V4 Pro takes text only, per DeepSeek's [models and pricing page](https://api-docs.deepseek.com/quick_start/pricing/): DSH does not let you attach an image to it, and an image already in the session (say, one switched over from Flash) is sent as a one-line "image omitted" note. PackyCode's gateway does not refuse an image sent to V4 Pro; it drops it.
+Of the thirteen models in the current catalog, all but DeepSeek V4 Pro declare text and image input. DeepSeek Flash follows the [official vision guide](https://api-docs.deepseek.com/guides/vision/); images are read through DSH's attachment service and sent with the Responses request. DeepSeek V4 Pro takes text only, per DeepSeek's [models and pricing page](https://api-docs.deepseek.com/quick_start/pricing/): DSH does not let you attach an image to it, and an image already in the session (say, one switched over from Flash) is sent as a one-line "image omitted" note. PackyCode's gateway does not refuse an image sent to V4 Pro; it drops it.
 
-Gemini 3.8 Flash's capabilities and limits follow Google's [model page](https://ai.google.dev/gemini-api/docs/models/gemini-3.8-flash). It uses the native Gemini protocol through `/v1beta/models/{model}:streamGenerateContent`, streaming text, thinking and tool calls; images are read through DSH's attachment service. Thinking levels are sent with `thinkingLevel`. It uses the single-stream output limit without automatic continuation beyond 65,536 tokens. Available endpoints and groups follow the [PackyAPI live model catalog](https://www.packyapi.com/api/pricing). PackyCode stopped serving Gemini 4 Argon on 2026-10-27, and the plugin no longer lists it.
+Gemini capabilities and limits follow Google's model pages: [Gemini 4 Argon](https://ai.google.dev/gemini-api/docs/models/gemini-4-argon), [Gemini 3.8 Flash](https://ai.google.dev/gemini-api/docs/models/gemini-3.8-flash). Both models use the native Gemini protocol through `/v1beta/models/{model}:streamGenerateContent`, streaming text, thinking and tool calls; images are read through DSH's attachment service. Thinking levels are sent with `thinkingLevel`. Both routes use the single-stream output limit without automatic continuation beyond 65,536 tokens. Available endpoints and groups follow the [PackyAPI live model catalog](https://www.packyapi.com/api/pricing).
 
-**Gemini tool continuation and thought signatures:** PackyCode's native Gemini route does not handle thought signatures in tool calls correctly. It answers HTTP 400 `Invalid thought signature` / `Corrupted thought signature`, and resending the same request does not help (PackyCode support's answer). For Gemini 3.8 Flash the plugin therefore sends none of the signatures the model returned. Wherever a signature is required, it sends Google's documented validator-skip value `skip_thought_signature_validator` ([Google's guide](https://ai.google.dev/gemini-api/docs/thought-signatures)). The protocol, endpoint and model stay the same, and DSH's replay record keeps the original signatures. Google notes that skipped signatures can weaken reasoning continuity across tool steps. Flash keeps its earlier safeguard: after an HTTP 400 signature refusal before any stream event, it waits one second and resends once. Such a 400 is never treated as a failed key.
+**Gemini tool continuation and thought signatures:** PackyCode's native Gemini route does not handle thought signatures in tool calls correctly. It answers HTTP 400 `Invalid thought signature` / `Corrupted thought signature`, and resending the same request does not help (PackyCode support's answer). For Gemini 4 Argon and Gemini 3.8 Flash the plugin therefore sends none of the signatures the model returned. Wherever a signature is required, it sends Google's documented validator-skip value `skip_thought_signature_validator` ([Google's guide](https://ai.google.dev/gemini-api/docs/thought-signatures)). The protocol, endpoint and model stay the same, and DSH's replay record keeps the original signatures. Google notes that skipped signatures can weaken reasoning continuity across tool steps. Flash keeps its earlier safeguard: after an HTTP 400 signature refusal before any stream event, it waits one second and resends once. Such a 400 is never treated as a failed key.
 
 Grok 4.7's context and reasoning levels follow the [official guide](https://docs.x.ai/developers/grok-4-7). There is no separate text-output limit; the plugin uses the context size as its numeric output ceiling, bounded by the remaining context per request.
 
-Only GPT Responses requests keep `prompt_cache_key`; other Responses models omit it by default. This gateway's Grok route reports a misleading `Incorrect API key provided` error when the field is present, and DeepSeek Flash hits its prefix cache without it. GPT tool definitions also carry an explicit `strict: false`: PackyCode's GPT route treats a tool without `strict` as strict, which forces the model to fill every optional parameter (see the FAQ).
+Hy4's protocols, context, output limit and image input follow Tencent Cloud TokenHub's [Hunyuan guide](https://cloud.tencent.com/document/product/1823/132252), and its effort levels follow the [deep thinking page](https://cloud.tencent.com/document/product/1823/131208): Hy4 thinks by default, and `reasoning_effort` takes only `high` and `no_think`. The plugin sends `high` as is; with effort off it sends `reasoning.effort: "no_think"`, and the answer comes back without reasoning. The gateway also accepts `low`, `medium`, `xhigh` and `max`, but Hy4's documentation does not list them, and in testing they came back with the same prompt tokens as `high` and no consistent difference in reasoning, so the plugin does not offer them. Images are read through DSH's attachment service and sent with the Responses request, as for DeepSeek Flash. Reasoning comes back as `summary_text` items; as TokenHub's [preserved thinking](https://cloud.tencent.com/document/product/1823/133534) asks, the plugin sends it back unchanged with tool continuations and in later turns. DSH's system prompt says only "powered by DeepSeek Harness" and "powered by the hy4 model", without saying whose model hy4 is, and Hy4 then calls itself a DeepSeek model and denies being Hunyuan (the other models recognize their own ids). So the plugin ends the system prompt of every Hy4 request with one sentence: hy4 is Tencent Hunyuan's Hy4, reached through PackyCode, and DeepSeek Harness is only the app it runs in. DSH's own prompt is kept as written, and other models' requests are unchanged.
+
+Only GPT Responses requests keep `prompt_cache_key`; other Responses models omit it by default. This gateway's Grok route reports a misleading `Incorrect API key provided` error when the field is present, and DeepSeek Flash and Hy4 hit their prefix caches without it. GPT tool definitions also carry an explicit `strict: false`: PackyCode's GPT route treats a tool without `strict` as strict, which forces the model to fill every optional parameter (see the FAQ).
 
 GPT-6.1 Terra's context, output limit and effort levels follow OpenAI's [model page](https://developers.openai.com/api/docs/models/gpt-6.1-terra). It is the only GPT model whose reasoning can be off: with effort off it sends `reasoning.effort: "none"`, which the gateway passes through, and the answer comes back without reasoning. GPT-5.6 Sol's documentation lists `none` too, but through PackyCode it answers at `medium`, so it cannot be off.
 
@@ -271,9 +275,9 @@ DeepSeek Flash uses the gateway's Responses endpoint (`/api/pricing` lists `open
 
 ## Update and uninstall
 
-> **Upgrading from 1.3.2 or earlier:** install `dsh-packycode-api@1.4.4` on the Plugins page instead of clicking **Update plugin** in the old settings card. The old button bypasses pnpm's release-age policy: if the version it installs is less than 24 hours old, the profile refuses every other plugin install until that version is 24 hours old. After the install and a restart, the button is the fixed one, and later updates can use it.
+> **Upgrading from 1.3.2 or earlier:** install `dsh-packycode-api@1.4.6` on the Plugins page instead of clicking **Update plugin** in the old settings card. The old button bypasses pnpm's release-age policy: if the version it installs is less than 24 hours old, the profile refuses every other plugin install until that version is 24 hours old. After the install and a restart, the button is the fixed one, and later updates can use it.
 
-**Update:** open **Settings → PackyCode** and, when a newer version is listed, click **Update plugin**. It installs that exact version into the owning profile with DSH's bundled pnpm and reads `package.json` back before reporting success. The install keeps pnpm's release-age policy instead of overriding it: by default pnpm installs the version at once and records it in the profile's `minimumReleaseAgeExclude`; under a stricter pnpm policy the button says when the update can run. The newer version is read from npm, while pnpm downloads it from the profile's own install source: right after a release that source (a regional mirror in particular) may not have it yet, and the button asks you to update again in a few minutes; when the source cannot be reached, it asks you to check the network or proxy. A local `link:` checkout does not get the button. Then quit and reopen the desktop application. A page refresh does not reload the Host. Reinstalling from the **Plugins** page works too, again with the version in the package name (for example `dsh-packycode-api@1.4.4`); without it you may get a version that is merely the newest one published at least 24 hours ago.
+**Update:** open **Settings → PackyCode** and, when a newer version is listed, click **Update plugin**. It installs that exact version into the owning profile with DSH's bundled pnpm and reads `package.json` back before reporting success. The install keeps pnpm's release-age policy instead of overriding it: by default pnpm installs the version at once and records it in the profile's `minimumReleaseAgeExclude`; under a stricter pnpm policy the button says when the update can run. The newer version is read from npm, while pnpm downloads it from the profile's own install source: right after a release that source (a regional mirror in particular) may not have it yet, and the button asks you to update again in a few minutes; when the source cannot be reached, it asks you to check the network or proxy. A local `link:` checkout does not get the button. Then quit and reopen the desktop application. A page refresh does not reload the Host. Reinstalling from the **Plugins** page works too, again with the version in the package name (for example `dsh-packycode-api@1.4.6`); without it you may get a version that is merely the newest one published at least 24 hours ago.
 
 **Coming back from a local-path install, uninstall first.** An update is a `pnpm add`: it rewrites the files inside the package directory and leaves a `node_modules` that an earlier local-path install left there. That older tree keeps shadowing the packages the DSH installation provides, so the plugin row fails to load with no visible reason. **Uninstall** runs `pnpm remove`, which deletes the package directory outright — only a reinstall after that is clean. `node scripts/install-check.mjs` reports whether a profile is in that state.
 
@@ -289,7 +293,7 @@ ls ~/.dsh/profiles/desktop/node_modules/dsh-packycode-api/node_modules
 
 Output means a leftover tree: a registry install ships no `node_modules`, so this one usually comes from an earlier local-path install (`file:`, or a bare path instead of `link:`). It sits inside the profile directory, and DSH resolves a plugin's imports from inside the profile first, so the plugin gets those old copies — for example `@deepseek-ai/schemastery` 3.18.2, which has no `Schema.volatile()`, so the module throws while it is imported. When an import fails the Loader creates no fiber for that row and no client bundle is composed either, so the model route, the RPC channel, and the settings panel all stay absent.
 
-Recovery: **uninstall** the plugin on the **Plugins** page, **install** it again with the version in the package name (for example `dsh-packycode-api@1.4.4`), then quit and reopen the desktop application. Uninstall runs `pnpm remove` and deletes the whole package directory; reinstalling or clicking **Update** only rewrites files and keeps the leftover tree. Deleting that `node_modules` by hand and restarting works too.
+Recovery: **uninstall** the plugin on the **Plugins** page, **install** it again with the version in the package name (for example `dsh-packycode-api@1.4.6`), then quit and reopen the desktop application. Uninstall runs `pnpm remove` and deletes the whole package directory; reinstalling or clicking **Update** only rewrites files and keeps the leftover tree. Deleting that `node_modules` by hand and restarting works too.
 
 **Right after a first install, every card in Settings shows `transport failure for /packycode-api/…: HTTP 405`?** The installed version is 1.1.6 or earlier, usually because only the bare package name was entered: the install prompt shows the newest version, but pnpm installs the newest one published at least 24 hours ago (see **Install the plugin**). Those older versions can register their settings channel only after DSH restarts and rebuilds its `connection` service. So right after a first install `/packycode-api` does not exist yet, requests fall through to the static page, and it answers 405; the model route and the settings panel itself load normally. From 1.1.7 on, a first install needs no restart. Check which version was installed:
 
@@ -305,8 +309,6 @@ Recovery: quit and reopen the desktop application, and the old version works. Th
 
 **A GPT model's file edit fails with `invalid justification: expected a non-empty sentence`?** This affected 1.4.2 and earlier; update to 1.4.3. PackyCode's GPT route treats a tool without `strict` as strict, so the model had to fill every optional parameter. It sent DSH's sandbox escalation pair as `sandbox_permissions: "workspace-write"` with an empty `justification`, and DSH's edit and write refused the call. From 1.4.3 GPT tool definitions carry an explicit `strict: false`. The model usually finishes the step another way, and existing sessions need nothing.
 
-**A session says `pi-ai provider "packycode" has no configured model "gemini-4-argon"`?** PackyCode stopped serving Gemini 4 Argon on 2026-10-27: the gateway refuses it, and the plugin removed it from its catalog. Pick another model for that session in the model picker.
-
 **Claude reports an official-client-only or client-anomaly refusal?** This is a gateway client-policy refusal, not proof of an invalid key. See whether the key is marked “Claude via HTTP” or “via official CLI”: a `cc` key always uses the CLI, and other groups use HTTP. The cc group judges whether a request comes from Claude Code itself; from 1.4.0 cc sessions are carried out by Claude Code and are normally accepted. If one is still refused, resend it; if it keeps happening, send the gateway's own words from the error (with the request id) to PackyCode support, or use a `cc-sale` / `cc-expensive` / `claude-officially` key. Updating the Claude Code CLI does not help with this refusal. The plugin does not disable the key or switch providers.
 
 **“Claude Code CLI is not available”?** The key is in `cc`, which needs the CLI on this device. When the message says the key's groups are not read yet, the group reading failed for now (common on an unstable network or proxy): resend shortly, and a key outside `cc` moves to HTTP once its groups are read. Under **Settings → PackyCode → Claude Code CLI** click Install, or run `npm install -g @anthropic-ai/claude-code --allow-scripts=@anthropic-ai/claude-code` and click Check again; set `claudeCliPath` for an unusual location. Otherwise use a `cc-sale` / `cc-expensive` key.
@@ -325,7 +327,7 @@ Recovery: quit and reopen the desktop application, and the old version works. Th
 
 **Do I need Claude Code installed?** Only for Claude models on a `cc` key. The plugin runs it with its own config home and never touches your Claude Code login or settings; it updates the installation only when you click **Update Claude Code CLI**. Other groups and models do not need it.
 
-**Replies stop at the output token limit (已达到输出 token 上限), or requests keep failing — how do I report it?** Open **Settings → PackyCode → Diagnostics**, pick the session (the 20 most recent, newest first, labelled with their folder name), click **Generate diagnostics** and then **Copy**, and paste the text into an [Issue](https://github.com/BaronCyrus/dsh-packycode-api/issues) or send it to the plugin author. It holds settings and numbers only: the plugin version, the session id and start time, each key's position and groups (no labels, no keys), each request's model, reasoning effort and output limit, the latest steps' token usage and finish reasons, and retry and failure codes (messages redacted and shortened). It contains no conversation text, file paths or keys. Where copying is unavailable, the text is selected instead; press ⌘C or Ctrl+C.
+**Replies stop at the output token limit (已达到输出 token 上限), or requests keep failing — how do I report it?** Open **Settings → PackyCode → Diagnostics**, pick the session (the 20 most recent, newest first, labelled with their folder name), click **Generate diagnostics** and then **Copy**, and paste the text into an [Issue](https://github.com/BaronCyrus/dsh-packycode-api/issues) or send it to the plugin author. It holds settings and numbers only: the plugin version, the session id and start time, each key's position and groups (no labels, no keys), each request's model, reasoning effort and output limit, the latest steps' token usage and finish reasons, and retry and failure codes (messages redacted and shortened). A `network` section covers this plugin's connections to PackyCode's servers since it loaded, across sessions: the Node version, its connection settings (address family autoselection and how long each address gets) and which scheme each proxy variable names (never the proxy itself), then for each server the addresses it resolves to now, its requests, statuses, failures, cancellations and time to response headers, and for the 12 latest failures the stage (connect, request or mid-response), the time taken, the underlying error codes and how each tried address failed. It contains no conversation text, file paths or keys. Where copying is unavailable, the text is selected instead; press ⌘C or Ctrl+C.
 
 ## Security and scope
 

package/README.md

@@ -48,10 +48,10 @@
 打开桌面应用的**插件**页，点击**添加插件**，在**包名或地址**中填入**带版本号**的包名：
 
 ```text
-dsh-packycode-api@1.4.4
+dsh-packycode-api@1.4.6
 ```
 
-在**安装源**中选择**官方源**，然后点击**安装**。`1.4.4` 是写这份说明时的最新版，当前最新版本号以 [npm 页面](https://www.npmjs.com/package/dsh-packycode-api) 为准。
+在**安装源**中选择**官方源**，然后点击**安装**。`1.4.6` 是写这份说明时的最新版，当前最新版本号以 [npm 页面](https://www.npmjs.com/package/dsh-packycode-api) 为准。
 
 > **一定要带版本号。** 只填 `dsh-packycode-api` 时，安装前的提示显示的是 npm 上的最新版，但 DSH 自带的 pnpm 默认只安装发布满 24 小时的版本，实际装上的可能是好几个版本之前的旧版，而安装提示里看不出这一点。填写精确版本时，pnpm 会直接安装这个版本，并自动把它加入 profile 的 `minimumReleaseAgeExclude`。装好后可以在 **设置 → PackyCode → 插件版本** 核对「当前版本」。
 
@@ -65,14 +65,14 @@ dsh-packycode-api@1.4.4
 
 ### 3. 选择模型
 
-回到对话，在模型选择器里选 `PackyCode` 分组下的模型。十一个模型里，Claude 在 `cc` 分组的 Key 上由本机 Claude Code CLI 执行，其余都通过插件内 HTTP 调用；Key 的分组必须覆盖所选模型。
+回到对话，在模型选择器里选 `PackyCode` 分组下的模型。十三个模型里，Claude 在 `cc` 分组的 Key 上由本机 Claude Code CLI 执行，其余都通过插件内 HTTP 调用；Key 的分组必须覆盖所选模型。
 
 <details>
 <summary>检查安装 / 其它 profile / 本地目录</summary>
 
 桌面应用的**插件**页可以看到已安装状态与版本，也可以在那里启用、停用或卸载。
 
-**仅用于非 desktop profile：** `dsh plugin --profile <name> add dsh-packycode-api@1.4.4`。不要对 `desktop` 使用它 —— CLI 会直接拒绝（`profile "desktop" is managed exclusively by the Electron application`）。
+**仅用于非 desktop profile：** `dsh plugin --profile <name> add dsh-packycode-api@1.4.6`。不要对 `desktop` 使用它 —— CLI 会直接拒绝（`profile "desktop" is managed exclusively by the Electron application`）。
 
 本地开发要加 `link:` 前缀：`dsh plugin --profile <name> add link:/path/to/dsh-packycode-api`。**不要直接写路径（或 `file:`）** —— 那样的安装会把整个仓库目录（连同 `node_modules`）复制进 profile，之后它会在 profile 内部挡住 DSH 自带的包，插件看起来像没装，见「常见问题」。已经那样装过的话，先卸载再按上面的方式重装。
 
@@ -86,7 +86,7 @@ dsh-packycode-api@1.4.4
 
 **换 Key。** Key 按添加顺序使用。点「切到此 Key」指定优先使用的 Key，下一轮就生效；「重命名」改备注（最多 60 字，不能为空）；充值或更换后点「重新启用」。
 
-**看分组。** 「账户与 Key」里每个 Key 下面列出它所在的 PackyCode 分组（鼠标悬停可看分组说明），以及能用哪些模型：✓ 可用、◐ 部分可用、✕ 不可用。分组由网关自己报出（对一个不存在的模型 id 的拒绝里会写明「已选分组」，单分组的 Key 则是「分组 … 下模型 … 无可用渠道」，不产生费用），再对照 PackyCode 公开的模型分组表。Claude 的分组覆盖要按具体模型确认，不能假定 `cc-sale` 支持全部三个型号；GPT 需要 `codex` / `codex-sale`；DeepSeek 需要 `deepseek-officially` / `deepseek-sale`。
+**看分组。** 「账户与 Key」里每个 Key 下面列出它所在的 PackyCode 分组（鼠标悬停可看分组说明），以及能用哪些模型：✓ 可用、◐ 部分可用、✕ 不可用。分组由网关自己报出（对一个不存在的模型 id 的拒绝里会写明「已选分组」，单分组的 Key 则是「分组 … 下模型 … 无可用渠道」，不产生费用），再对照 PackyCode 公开的模型分组表。Claude 的分组覆盖要按具体模型确认，不能假定 `cc-sale` 支持全部三个型号；GPT 需要 `codex` / `codex-sale`；DeepSeek 需要 `deepseek-officially` / `deepseek-sale`；Hy4 需要 `hunyuan-officially`。
 
 **看余额。** 「账户与 Key」里每个 Key 显示它自己的剩余、已用与额度（额度 = 剩余 + 已用），不限额的 Key 显示「不限额度」；多个 Key 不相加成合计。API Key 只能读到自己的额度，读不到 PackyCode 账号的总余额，账号余额请到 PackyCode 控制台查看。读失败的 Key 会在它那一行注明原因；某个 Key 这次读失败但之前读到过，会继续显示上次的余额并注明读取时间（输入框里显示为 `≈US$…`），重启 DSH 后才清空。输入框右侧只在选中 PackyCode 模型时显示当前 Key 的剩余额度。「刷新」会跳过约 60 秒的缓存。默认模型接口是 `https://cf.api.fan`，余额接口是 `https://www.packyapi.ai`，可在「高级：接口地址」里改。旧默认值 `https://www.packyapi.com` 在国内网络下 DNS 被污染、直连会 `fetch failed`，即使设置里保存的是它，插件也会先试 `.ai`。
 
@@ -227,6 +227,8 @@ DSH 自带一个实验性插件「自动授权审查」，默认关闭。开启
 | `gpt-6-astra` | 同上 | 不能关；`low` / `medium` / `high` / `xhigh` / `max` | 同上 |
 | `gpt-5.6-sol` | 同上 | 同上 | 同上 |
 | `grok-4.7`（Grok 4.7） | HTTP，Responses，可带图；500k 上下文 | 不能关；`low` / `medium` / `high` / `xhigh` | 以设置页从网关读取的 Grok 分组覆盖为准 |
+| `hy4`（Hy4，腾讯混元） | HTTP，Responses，可带图；1024K 上下文（输入最多 960K），64K 输出 | 可关；只有 `high` | `hunyuan-officially` |
+| `gemini-4-argon`（Gemini 4 Argon） | HTTP，Gemini 原生流式，可带图；1,048,576 上下文，65,536 输出 | 不能关；`low` / `medium` / `high` | `gemini-slb` |
 | `gemini-3.8-flash`（Gemini 3.8 Flash） | HTTP，Gemini 原生流式，可带图；1,048,576 输入，65,536 输出 | 不能关；`low` / `medium` / `high` | `gemini-slb` |
 | `claude-opus-5-5` | Anthropic Messages，可带图和原生工具：`cc` 分组由本机 Claude Code CLI 当 agent，其它分组走 HTTP | 不能关；`low` / `medium` / `high` / `xhigh` / `max` | 以设置页读取的 Claude 分组覆盖为准 |
 | `claude-sonnet-5-5` | 同上 | 同上 | 同上 |
@@ -236,15 +238,17 @@ DSH 自带一个实验性插件「自动授权审查」，默认关闭。开启
 
 `jev-latest`（TypeSafe Jev）不在模型选择器里：它是只回答分类问题的决策模型，不能对话，只用于[自动审查](#自动审查)。插件在宿主侧直接调用 `/v1/systemone`，需要 Key 在 `typesafe-officially` 分组；「账户与 Key」里每个 Key 的「Jev」一项会显示能否使用。
 
-当前目录的 11 个模型中，除 DeepSeek V4 Pro 外都声明了文字和图像输入。DeepSeek Flash 的识图能力按 [官方图像理解文档](https://api-docs.deepseek.com/zh-cn/guides/vision/) 配置；图片通过 DSH 附件服务读取，再随 Responses 请求发送。DeepSeek V4 Pro 按 [官方模型与价格页](https://api-docs.deepseek.com/zh-cn/quick_start/pricing/) 只收文字：DSH 不让给它附图，会话里已有的图片（比如从 Flash 切过来的会话）会换成一行「图片已省略」的说明再发送。PackyCode 网关收到发给 V4 Pro 的图片不报错，而是直接丢掉。
+当前目录的 13 个模型中，除 DeepSeek V4 Pro 外都声明了文字和图像输入。DeepSeek Flash 的识图能力按 [官方图像理解文档](https://api-docs.deepseek.com/zh-cn/guides/vision/) 配置；图片通过 DSH 附件服务读取，再随 Responses 请求发送。DeepSeek V4 Pro 按 [官方模型与价格页](https://api-docs.deepseek.com/zh-cn/quick_start/pricing/) 只收文字：DSH 不让给它附图，会话里已有的图片（比如从 Flash 切过来的会话）会换成一行「图片已省略」的说明再发送。PackyCode 网关收到发给 V4 Pro 的图片不报错，而是直接丢掉。
 
-Gemini 3.8 Flash 的能力与限制来自 Google 官方[模型页](https://ai.google.dev/gemini-api/docs/models/gemini-3.8-flash)。它使用 Gemini 原生协议，通过 `/v1beta/models/{model}:streamGenerateContent` 流式返回文字、思考和工具调用，图片仍由 DSH 附件服务读取。思考档位通过 `thinkingLevel` 传入。它使用单次流式输出上限，不执行超过 65,536 token 的自动续写。可用端点与分组以 [PackyAPI 实时模型目录](https://www.packyapi.com/api/pricing) 为准。PackyCode 自 2026-10-27 起不再提供 Gemini 4 Argon，插件已从目录中移除它。
+Gemini 的能力与限制来自 Google 官方模型页：[Gemini 4 Argon](https://ai.google.dev/gemini-api/docs/models/gemini-4-argon)、[Gemini 3.8 Flash](https://ai.google.dev/gemini-api/docs/models/gemini-3.8-flash)。两款模型统一使用 Gemini 原生协议，通过 `/v1beta/models/{model}:streamGenerateContent` 流式返回文字、思考和工具调用，图片仍由 DSH 附件服务读取。思考档位通过 `thinkingLevel` 传入。两者均使用单次流式输出上限，不执行超过 65,536 token 的自动续写。可用端点与分组以 [PackyAPI 实时模型目录](https://www.packyapi.com/api/pricing) 为准。
 
-**Gemini 工具续聊的思维签名：** PackyCode 的 Gemini 原生通道在工具调用场景下不能正确处理思维签名，会返回 HTTP 400 `Invalid thought signature` / `Corrupted thought signature`，原样重发也无济于事（PackyCode 客服的答复）。因此插件对 Gemini 3.8 Flash 不再回传模型返回的签名，而是按 [Google 文档](https://ai.google.dev/gemini-api/docs/thought-signatures) 在需要签名的位置填入跳过校验的值 `skip_thought_signature_validator`。协议、端点和模型都不变，DSH 的回放记录仍保留原始签名。Google 提示跳过签名可能削弱多步工具调用之间的推理连贯性。Flash 仍保留原有兜底：HTTP 400 签名拒绝且尚未输出任何流事件时，等待 1 秒原样重发一次。这类 400 不会被当作 Key 失效。
+**Gemini 工具续聊的思维签名：** PackyCode 的 Gemini 原生通道在工具调用场景下不能正确处理思维签名，会返回 HTTP 400 `Invalid thought signature` / `Corrupted thought signature`，原样重发也无济于事（PackyCode 客服的答复）。因此插件对 Gemini 4 Argon 和 Gemini 3.8 Flash 不再回传模型返回的签名，而是按 [Google 文档](https://ai.google.dev/gemini-api/docs/thought-signatures) 在需要签名的位置填入跳过校验的值 `skip_thought_signature_validator`。协议、端点和模型都不变，DSH 的回放记录仍保留原始签名。Google 提示跳过签名可能削弱多步工具调用之间的推理连贯性。Flash 仍保留原有兜底：HTTP 400 签名拒绝且尚未输出任何流事件时，等待 1 秒原样重发一次。这类 400 不会被当作 Key 失效。
 
 Grok 4.7 的上下文与推理档位来自 [官方文档](https://docs.x.ai/developers/grok-4-7)。官方没有单独限制文字输出长度；插件将输出上限设为上下文大小，并按每次请求的剩余上下文收紧。
 
-Responses 请求只有 GPT 模型保留 `prompt_cache_key`，其他 Responses 模型默认省略。当前网关的 Grok 路由会将这个字段误报成 `Incorrect API key provided`；DeepSeek Flash 不带它也能命中前缀缓存。GPT 的工具定义还会显式带上 `strict: false`：PackyCode 的 GPT 通道把没写 `strict` 的工具当作严格模式，模型会被迫填满所有可选参数（见「常见问题」）。
+Hy4 的协议、上下文、输出上限和识图能力来自腾讯云 TokenHub 的 [混元调用指南](https://cloud.tencent.com/document/product/1823/132252)，推理档位来自 [深度思考](https://cloud.tencent.com/document/product/1823/131208)：Hy4 默认开启思考，`reasoning_effort` 只有 `high` 和 `no_think` 两档。插件按 `high` 发送，关闭推理时发送 `reasoning.effort: "no_think"`，返回时不带思考。网关也接受 `low`、`medium`、`xhigh`、`max`，但 Hy4 的文档没有这些档位，实测时它们的提示 token 与 `high` 相同，推理长度也看不出差别，所以插件不提供。图片和 DeepSeek Flash 一样由 DSH 附件服务读取，随 Responses 请求发送。推理以 `summary_text` 条目返回；按 TokenHub [保留式思考](https://cloud.tencent.com/document/product/1823/133534) 的要求，插件把推理原样回传给工具续聊和之后的轮次。DSH 的系统提示词只写了「powered by DeepSeek Harness」和「powered by the hy4 model」，没说 hy4 是谁家的模型，hy4 会因此自称 DeepSeek 的模型、否认自己是混元（其它模型都认得出自己的模型名）。所以插件在 hy4 每个请求的系统提示词末尾补一句英文说明：hy4 是腾讯混元的 Hy4，经 PackyCode 接入，DeepSeek Harness 只是运行它的应用。DSH 自己的提示词原样保留，其它模型的请求不受影响。
+
+Responses 请求只有 GPT 模型保留 `prompt_cache_key`，其他 Responses 模型默认省略。当前网关的 Grok 路由会将这个字段误报成 `Incorrect API key provided`；DeepSeek Flash 和 Hy4 不带它也能命中前缀缓存。GPT 的工具定义还会显式带上 `strict: false`：PackyCode 的 GPT 通道把没写 `strict` 的工具当作严格模式，模型会被迫填满所有可选参数（见「常见问题」）。
 
 GPT-6.1 Terra 的上下文、输出上限和推理档位来自 [OpenAI 模型页](https://developers.openai.com/api/docs/models/gpt-6.1-terra)。它是唯一可以关闭推理的 GPT 模型：关闭时发送 `reasoning.effort: "none"`，网关原样转发，返回时不带思考。GPT-5.6 Sol 的文档虽然也列出 `none`，经 PackyCode 却按 `medium` 回答，所以不能关。
 
@@ -271,9 +275,9 @@ DeepSeek Flash 走网关的 Responses 接口（`/api/pricing` 列出 `openai-res
 
 ## 更新与卸载
 
-> **从 1.3.2 或更早版本升级：** 请在插件页填写 `dsh-packycode-api@1.4.4` 安装，不要点旧版设置页里的「更新插件」。旧按钮安装时会绕过 pnpm 的发布冷却期：装到的版本如果发布还不满 24 小时，这个 profile 在它满 24 小时之前就装不了其他插件。装好并重启后，按钮就换成了修好的版本，以后直接点即可。
+> **从 1.3.2 或更早版本升级：** 请在插件页填写 `dsh-packycode-api@1.4.6` 安装，不要点旧版设置页里的「更新插件」。旧按钮安装时会绕过 pnpm 的发布冷却期：装到的版本如果发布还不满 24 小时，这个 profile 在它满 24 小时之前就装不了其他插件。装好并重启后，按钮就换成了修好的版本，以后直接点即可。
 
-**更新：** 打开 **设置 → PackyCode**，有新版本时点「更新插件」。它会在当前 profile 目录里用 DSH 自带的 pnpm 安装精确版本，并读回 `package.json` 确认版本落地。安装遵守 pnpm 的发布冷却策略，不会绕过它：默认情况下 pnpm 会直接装上这个版本，并把它记进 profile 的 `minimumReleaseAgeExclude`；如果你给 pnpm 配了更严格的策略，按钮会提示什么时候可以更新。新版本号是从 npm 读到的，pnpm 却从 profile 配置的安装源下载：刚发布的版本，安装源（尤其是国内镜像）可能还没同步到，这时按钮会提示过几分钟再更新；连不上安装源时，会提示检查网络或代理。本地 `link:` 开发安装不会出现这个按钮。完成后完全退出并重新打开桌面应用。只刷新页面不会重载 Host。也可以在**插件**页重新安装，同样要填写带版本号的包名（例如 `dsh-packycode-api@1.4.4`），否则装上的可能是发布满 24 小时的旧版。
+**更新：** 打开 **设置 → PackyCode**，有新版本时点「更新插件」。它会在当前 profile 目录里用 DSH 自带的 pnpm 安装精确版本，并读回 `package.json` 确认版本落地。安装遵守 pnpm 的发布冷却策略，不会绕过它：默认情况下 pnpm 会直接装上这个版本，并把它记进 profile 的 `minimumReleaseAgeExclude`；如果你给 pnpm 配了更严格的策略，按钮会提示什么时候可以更新。新版本号是从 npm 读到的，pnpm 却从 profile 配置的安装源下载：刚发布的版本，安装源（尤其是国内镜像）可能还没同步到，这时按钮会提示过几分钟再更新；连不上安装源时，会提示检查网络或代理。本地 `link:` 开发安装不会出现这个按钮。完成后完全退出并重新打开桌面应用。只刷新页面不会重载 Host。也可以在**插件**页重新安装，同样要填写带版本号的包名（例如 `dsh-packycode-api@1.4.6`），否则装上的可能是发布满 24 小时的旧版。
 
 **从本地路径安装切回官方源时，必须先卸载。** 「更新」是 `pnpm add`，它只重写包目录里的文件，不会删除更早一次本地路径安装留在包目录内的 `node_modules`；那份旧依赖会继续挡住 DSH 自带的包，插件行加载失败且看不出原因。「卸载」执行的是 `pnpm remove`，会删掉整个包目录，重装才是干净的。用 `node scripts/install-check.mjs` 可以确认当前 profile 是否处于这个状态。
 
@@ -289,7 +293,7 @@ ls ~/.dsh/profiles/desktop/node_modules/dsh-packycode-api/node_modules
 
 有输出就是残留：从 npm 安装的包不会自带 `node_modules`，这一份通常来自更早一次「本地路径」安装（`file:` 或直接写路径，而不是 `link:`）。它位于 profile 目录内部，而 DSH 解析插件导入时优先使用 profile 内的副本，所以插件拿到的仍是那份旧依赖 —— 例如 `@deepseek-ai/schemastery` 3.18.2 没有 `Schema.volatile()`，模块在导入阶段就抛错。导入失败时 Loader 不会为这一行创建 fiber，客户端 bundle 也不会被组合，于是模型路由、RPC 通道和设置页全都不会出现。
 
-修复：到**插件**页**卸载**本插件，再用带版本号的包名重新**安装**（例如 `dsh-packycode-api@1.4.4`），然后完全退出并重新打开桌面应用。卸载执行的是 `pnpm remove`，会删掉整个包目录；直接重装或点「更新」只重写文件，不会清掉这份残留。也可以手动删掉上面那个 `node_modules` 再重启。
+修复：到**插件**页**卸载**本插件，再用带版本号的包名重新**安装**（例如 `dsh-packycode-api@1.4.6`），然后完全退出并重新打开桌面应用。卸载执行的是 `pnpm remove`，会删掉整个包目录；直接重装或点「更新」只重写文件，不会清掉这份残留。也可以手动删掉上面那个 `node_modules` 再重启。
 
 **首次安装后，设置页每张卡片都显示 `transport failure for /packycode-api/…: HTTP 405`？** 实际装上的是 1.1.6 或更早的版本，通常是因为安装时只填了包名：安装提示显示的是最新版，pnpm 实际装的却是发布满 24 小时的旧版（见「安装插件」）。这些旧版要等 DSH 重启、重建它的 `connection` 服务之后，才能注册设置通道。所以首次安装后 `/packycode-api` 通道还不存在，请求落到静态页面，返回 405；模型路由和设置页本身照常加载。1.1.7 起首次安装不需要重启。先确认装上的版本：
 
@@ -303,8 +307,6 @@ grep '"version"' ~/.dsh/profiles/desktop/node_modules/dsh-packycode-api/package.
 
 **GPT 模型改文件时报 `invalid justification: expected a non-empty sentence`？** 这是 1.4.2 及更早版本的问题，更新到 1.4.3 即可。PackyCode 的 GPT 通道把没写 `strict` 的工具当作严格模式，模型被迫填满所有可选参数，把 DSH 的沙箱提权参数填成 `sandbox_permissions: "workspace-write"` 加空的 `justification`，DSH 的 edit / write 于是拒绝这次调用。1.4.3 起 GPT 的工具定义显式带上 `strict: false`。模型通常会换一种方式完成这一步，已有会话不需要处理。
 
-**会话报 `pi-ai provider "packycode" has no configured model "gemini-4-argon"`？** PackyCode 自 2026-10-27 起不再提供 Gemini 4 Argon，网关拒绝这个模型，插件也从目录中移除了它。在模型选择器里给这个会话换一个模型即可。
-
 **Claude 报「只接受官方 Claude Code CLI」或「客户端存在异常」？** 这是网关的客户端政策拒绝，不等于 Key 失效。看这个 Key 下方标的是「Claude 经 HTTP」还是「经官方 CLI」：`cc` 分组的 Key 总是走 CLI，其它分组走 HTTP。cc 分组按请求内容判断是不是 Claude Code 自己在工作；1.4.0 起 cc 会话由 Claude Code 自己完成，正常不会被拒。偶尔仍被拒时重发一次；反复出现时，把错误里的网关原文（含 request id）发给 PackyCode 客服，或改用 `cc-sale` / `cc-expensive` / `claude-officially` 分组的 Key。更新 Claude Code CLI 不能解决这个拒绝。插件不会因此禁用 Key 或切换提供商。
 
 **提示「本机没有可用的 Claude Code CLI」？** 当前 Key 在 `cc` 分组，需要本机 CLI。提示里写着「插件还没读到当前 Key 的分组」时，是分组读取暂时失败（网络或代理不稳时常见）：稍后重发即可，不在 `cc` 分组的 Key 读到分组后会自动改走 HTTP。到 **设置 → PackyCode → Claude Code CLI** 点「安装」，或在终端执行 `npm install -g @anthropic-ai/claude-code --allow-scripts=@anthropic-ai/claude-code` 后点「重新检测」；装在非常规位置时可在配置里填 `claudeCliPath`。不想装的话，换用 `cc-sale` / `cc-expensive` 分组的 Key。
@@ -325,7 +327,7 @@ grep '"version"' ~/.dsh/profiles/desktop/node_modules/dsh-packycode-api/package.
 
 **需要安装 Claude Code 吗？** 只有 Key 在 `cc` 分组、又要用 Claude 模型时需要。插件用独立配置目录运行它，不改动你自己的 Claude Code 登录和设置；只有你点「更新 Claude Code CLI」时才会更新这份安装。其它分组和其它模型都不需要。
 
-**回答被截断（「已达到输出 token 上限」）、请求反复失败，怎么反馈？** 打开 **设置 → PackyCode → 诊断信息**，选出问题的会话（最近 20 个，按时间倒序，标着所在文件夹名），点「生成诊断信息」再点「复制」，把内容贴到 [Issue](https://github.com/BaronCyrus/dsh-packycode-api/issues) 或发给插件作者。内容只有设置和数字：插件版本、会话 id 与创建时间、每个 Key 的序号与分组（不含备注名和 Key 本身）、每次请求用的模型、推理档位和输出上限、最近若干步的 token 用量与结束原因，以及重试和失败的错误码（错误信息已脱敏并截短）。不含对话内容、文件路径和 Key。复制不可用时，文本会被全选，按 ⌘C 或 Ctrl+C 即可。
+**回答被截断（「已达到输出 token 上限」）、请求反复失败，怎么反馈？** 打开 **设置 → PackyCode → 诊断信息**，选出问题的会话（最近 20 个，按时间倒序，标着所在文件夹名），点「生成诊断信息」再点「复制」，把内容贴到 [Issue](https://github.com/BaronCyrus/dsh-packycode-api/issues) 或发给插件作者。内容只有设置和数字：插件版本、会话 id 与创建时间、每个 Key 的序号与分组（不含备注名和 Key 本身）、每次请求用的模型、推理档位和输出上限、最近若干步的 token 用量与结束原因，以及重试和失败的错误码（错误信息已脱敏并截短）。另有一段 `network`，记录插件这次运行以来连接 PackyCode 服务器的情况（不分会话）：Node 版本、连接设置（地址族自动选择及每个地址的等待时间）和代理变量的协议类型（不含代理地址），每个服务器当前解析到的地址、请求数、各状态码次数、失败与中止次数、响应头耗时，以及最近 12 次失败各自的阶段（连接、请求或响应中途）、耗时、底层错误码和每个尝试地址的结果。不含对话内容、文件路径和 Key。复制不可用时，文本会被全选，按 ⌘C 或 Ctrl+C 即可。
 
 ## 安全边界
 

package/lib/client.js

@@ -216,7 +216,7 @@ window.__ModuleLoader__.load({
 			diagCopy: "复制",
 			diagCopied: "已复制",
 			diagSelected: "已选中全部内容，请按 ⌘C 或 Ctrl+C 复制。",
-			diagPrivacy: "只包含模型、推理档位、输出上限、每一步的 token 用量和错误码，不含对话内容、文件路径和 Key。",
+			diagPrivacy: "只包含模型、推理档位、输出上限、每一步的 token 用量和错误码，以及本次运行中插件连接 PackyCode 服务器的情况（服务器地址、状态码、错误码、耗时和 Node 的连接设置），不含对话内容、文件路径和 Key。",
 			diagNoSessions: "还没有会话。",
 			diagLive: "进行中",
 			diagNoFolder: "无目录",
@@ -449,7 +449,7 @@ window.__ModuleLoader__.load({
 			diagCopy: "Copy",
 			diagCopied: "Copied",
 			diagSelected: "All text is selected; press ⌘C or Ctrl+C to copy.",
-			diagPrivacy: "Contains only models, reasoning effort, output limits, per-step token usage and error codes — no conversation text, file paths or keys.",
+			diagPrivacy: "Contains only models, reasoning effort, output limits, per-step token usage and error codes, plus how this run's connections to PackyCode's servers went (server addresses, statuses, error codes, timings and Node's connection settings) — no conversation text, file paths or keys.",
 			diagNoSessions: "No sessions yet.",
 			diagLive: "open",
 			diagNoFolder: "no folder",
@@ -1959,7 +1959,8 @@ window.__ModuleLoader__.load({
 				"gpt-5.6-sol"
 			]],
 			["Grok", ["grok-4.7"]],
-			["Gemini", ["gemini-3.8-flash"]],
+			["Hunyuan", ["hy4"]],
+			["Gemini", ["gemini-4-argon", "gemini-3.8-flash"]],
 			["Claude", [
 				"claude-opus-5-5",
 				"claude-sonnet-5-5",

package/lib/index.js

@@ -12,6 +12,9 @@ import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messag
 import { AsyncLocalStorage } from "node:async_hooks";
 import { HarnessError, LlmError, QUOTA_EXCEEDED_CODE, createUserMessage, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
 import { credentialKey } from "@deepseek-ai/dsh-credentials";
+import { subscribe, unsubscribe } from "node:diagnostics_channel";
+import * as dns from "node:dns";
+import * as net from "node:net";
 import { PiAiAdapter } from "@deepseek-ai/dsh-llm-pi-ai";
 import { lazyStream } from "@earendil-works/pi-ai/api/lazy";
 import { clampThinkingLevel, createProvider } from "@earendil-works/pi-ai";
@@ -1080,8 +1083,10 @@ const DEFAULT_REASONING_LEVEL = "high";
 * Astra and GPT-5.6 Sol `reasoning.effort` (developers.openai.com model
 * pages), DeepSeek thinking mode (`low|high|max` effort, or off, for Flash
 * and V4 Pro alike), Grok 4.7
-* (docs.x.ai/developers/grok-4-7), and Gemini 3.8 Flash
-* (ai.google.dev/gemini-api/docs/models/gemini-3.8-flash).
+* (docs.x.ai/developers/grok-4-7), Hy4 (`high` or `no_think`, TokenHub's
+* deep-thinking page cloud.tencent.com/document/product/1823/131208), and
+* Gemini 4 Argon and 3.8 Flash
+* (ai.google.dev/gemini-api/docs/models/gemini-4-argon and gemini-3.8-flash).
 *
 * @module dsh-packycode-api/catalog
 */
@@ -1101,8 +1106,8 @@ const GEMINI_BASE = `${DEFAULT_API_HOST}/v1beta`;
 * escalation pair then came back as `workspace-write` with an empty
 * justification, which DSH's edit and write refuse. Declaring strict-mode
 * support makes pi-ai send `strict: false` on each tool, as the official
-* Codex client does; the schemas stay as DSH wrote them. DeepSeek and Grok
-* leave optional parameters out either way.
+* Codex client does; the schemas stay as DSH wrote them. DeepSeek, Grok and
+* Hy4 fill optional parameters no more often without `strict` than with it.
 */
 const GPT_COMPAT = Object.freeze({ supportsStrictMode: true });
 /**
@@ -1152,7 +1157,23 @@ const GROK_LEVELS = Object.freeze({
 	...ALWAYS_THINKING_LEVELS,
 	max: null
 });
-/** Gemini 3.8 Flash supports low | medium | high, with no off. */
+/**
+* Hy4 documents `reasoning_effort` high | no_think and nothing else, with
+* thinking on by default. Through PackyCode `no_think` answers without
+* reasoning, so `off` sends it. The gateway does not refuse low, medium, xhigh
+* or max, but they are undocumented, and they came back with high's prompt
+* tokens and no consistent difference in reasoning, so they are not offered.
+*/
+const HY4_LEVELS = Object.freeze({
+	off: "no_think",
+	minimal: null,
+	low: null,
+	medium: null,
+	high: "high",
+	xhigh: null,
+	max: null
+});
+/** Gemini 4 Argon and 3.8 Flash support low | medium | high, with no off. */
 const GEMINI_LEVELS = Object.freeze({
 	...ALWAYS_THINKING_LEVELS,
 	xhigh: null,
@@ -1255,6 +1276,32 @@ const PACKYCODE_MODELS = Object.freeze([
 		thinkingLevelMap: GROK_LEVELS,
 		compat: Object.freeze({ supportsLongCacheRetention: false })
 	}),
+	Object.freeze({
+		id: "hy4",
+		name: "Hy4",
+		api: "openai-responses",
+		provider: PROVIDER,
+		baseUrl: RESPONSES_BASE,
+		reasoning: true,
+		input: Object.freeze(["text", "image"]),
+		cost: NO_COST,
+		contextWindow: 1024e3,
+		maxTokens: 64e3,
+		thinkingLevelMap: HY4_LEVELS
+	}),
+	Object.freeze({
+		id: "gemini-4-argon",
+		name: "Gemini 4 Argon",
+		api: "google-generative-ai",
+		provider: PROVIDER,
+		baseUrl: GEMINI_BASE,
+		reasoning: true,
+		input: Object.freeze(["text", "image"]),
+		cost: NO_COST,
+		contextWindow: 1048576,
+		maxTokens: 65536,
+		thinkingLevelMap: GEMINI_LEVELS
+	}),
 	Object.freeze({
 		id: "gemini-3.8-flash",
 		name: "Gemini 3.8 Flash",
@@ -6255,6 +6302,10 @@ function claudeTransportFor({ groups } = {}) {
 * each request used, how every model step ended and what it consumed, and
 * which retries and failures happened.
 *
+* The report also carries how this process reached PackyCode's servers
+* (`network.js`): it is process-wide, not per session, and starts when the
+* plugin loads.
+*
 * The summary carries numbers and identifiers only. Message text, reasoning,
 * tool arguments and results, titles, paths and key material never enter it;
 * error messages are redacted and shortened. A user can paste it into a bug
@@ -6277,12 +6328,12 @@ const DIAGNOSTICS_LIMITS = Object.freeze({
 });
 const finite = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
 /** Identifier-like strings only (routes, models, efforts, reason kinds, codes). */
-const word = (value) => typeof value === "string" && /^[\w.:/@[\]-]{1,80}$/u.test(value) ? value : void 0;
+const word$1 = (value) => typeof value === "string" && /^[\w.:/@[\]-]{1,80}$/u.test(value) ? value : void 0;
 const iso = (value) => finite(value) === void 0 ? void 0 : new Date(value).toISOString();
 const last = (list, count) => list.slice(Math.max(0, list.length - count));
-const compact = (object) => Object.fromEntries(Object.entries(object).filter(([, value]) => value !== void 0));
+const compact$1 = (object) => Object.fromEntries(Object.entries(object).filter(([, value]) => value !== void 0));
 const chunksOf = (stream) => Array.isArray(stream) ? stream.map((item) => item?.chunk).filter((chunk) => chunk !== null && typeof chunk === "object") : [];
-/** A provider or harness error message, redacted and shortened. */
+/** A provider, harness or transport error message, redacted and shortened. */
 function safeMessage$1(text, secrets) {
 	if (typeof text !== "string" || text === "") return void 0;
 	const safe = redactSecrets(text, secrets).replace(/sk-[A-Za-z0-9_-]{8,}/gu, "sk-[redacted]").replace(/Bearer\s+[A-Za-z0-9._~+/=-]{8,}/giu, "Bearer [redacted]").replace(/\s+/gu, " ").trim();
@@ -6291,7 +6342,7 @@ function safeMessage$1(text, secrets) {
 function failureOf(reason, secrets) {
 	const failure = reason?.failure ?? reason?.error;
 	return failure === void 0 ? {} : {
-		code: word(failure.code),
+		code: word$1(failure.code),
 		message: safeMessage$1(failure.message, secrets)
 	};
 }
@@ -6317,12 +6368,12 @@ function summarizeSessionEvents(events, { secrets = [] } = {}) {
 		if (type === "turn/start") turns += 1;
 		else if (type === "request/header") {
 			const config = data.header?.config ?? {};
-			requests.push(compact({
+			requests.push(compact$1({
 				time: iso(event.time),
-				reason: word(data.reason),
-				provider: word(config.provider),
-				model: word(config.model),
-				reasoningEffort: word(config.reasoningEffort),
+				reason: word$1(data.reason),
+				provider: word$1(config.provider),
+				model: word$1(config.model),
+				reasoningEffort: word$1(config.reasoningEffort),
 				maxTokens: finite(config.maxTokens),
 				maxTokensFromAdapter: data.header?.adapterDefaults?.maxTokens === true ? true : void 0
 			}));
@@ -6331,11 +6382,11 @@ function summarizeSessionEvents(events, { secrets = [] } = {}) {
 			const usage = data.usage ?? chunks.find((chunk) => chunk.type === "usage")?.usage ?? {};
 			const input = finite(usage.inputTokens);
 			const cacheRead = finite(usage.cacheReadTokens);
-			steps.push(compact({
+			steps.push(compact$1({
 				turn: finite(data.turn),
 				step: finite(data.step),
 				time: iso(event.time),
-				finish: word(chunks.find((chunk) => chunk.type === "finish")?.reason?.kind) ?? "none",
+				finish: word$1(chunks.find((chunk) => chunk.type === "finish")?.reason?.kind) ?? "none",
 				input,
 				cacheRead,
 				cacheWrite: finite(usage.cacheWriteTokens),
@@ -6344,26 +6395,26 @@ function summarizeSessionEvents(events, { secrets = [] } = {}) {
 			}));
 		} else if (type === "assistant/attempt") {
 			const reason = chunksOf(data.stream).find((chunk) => chunk.type === "finish")?.reason;
-			attempts.push(compact({
+			attempts.push(compact$1({
 				turn: finite(data.turn),
 				step: finite(data.step),
 				time: iso(event.time),
-				finish: word(reason?.kind),
+				finish: word$1(reason?.kind),
 				...failureOf(reason, secrets)
 			}));
-		} else if (type === "llm/retry") retries.push(compact({
+		} else if (type === "llm/retry") retries.push(compact$1({
 			turn: finite(data.turn),
 			step: finite(data.step),
 			time: iso(event.time),
-			provider: word(data.provider),
+			provider: word$1(data.provider),
 			retry: finite(data.retry),
 			maxRetries: finite(data.maxRetries),
 			...failureOf({ failure: data.failure }, secrets)
 		}));
-		else if (type === "turn/end") turnEnds.push(compact({
+		else if (type === "turn/end") turnEnds.push(compact$1({
 			turn: finite(data.turn),
 			time: iso(event.time),
-			kind: word(data.reason?.kind),
+			kind: word$1(data.reason?.kind),
 			...failureOf(data.reason, secrets)
 		}));
 	}
@@ -6389,9 +6440,10 @@ function summarizeSessionEvents(events, { secrets = [] } = {}) {
 * The diagnostics service behind the settings card.
 * @param options - DSH's session query service (read lazily), the session
 *   event reader the image originals already use, the key ring and group
-*   reader, the stored secrets to redact, and this package's manifest URL.
+*   reader, the stored secrets to redact, this package's manifest URL, and
+*   the network log.
 */
-function createDiagnostics({ sessionQuery, readEvents, ring, groups, secrets = async () => [], ownPackageJsonUrl }) {
+function createDiagnostics({ sessionQuery, readEvents, ring, groups, secrets = async () => [], ownPackageJsonUrl, network }) {
 	const query = () => {
 		const service = sessionQuery?.();
 		if (typeof service?.listSessions !== "function") throw new Error("PackyCode diagnostics need DSH session history, which this runtime does not provide");
@@ -6399,7 +6451,7 @@ function createDiagnostics({ sessionQuery, readEvents, ring, groups, secrets = a
 	};
 	const version = async () => {
 		try {
-			return word(JSON.parse(await readFile(fileURLToPath(ownPackageJsonUrl), "utf8")).version);
+			return word$1(JSON.parse(await readFile(fileURLToPath(ownPackageJsonUrl), "utf8")).version);
 		} catch {
 			return;
 		}
@@ -6415,19 +6467,27 @@ function createDiagnostics({ sessionQuery, readEvents, ring, groups, secrets = a
 		}
 		return listed.map((entry, index) => {
 			const group = reading?.keys?.find((item) => item.id === entry.id);
-			return compact({
+			return compact$1({
 				key: index + 1,
 				active: entry.active === true,
 				disabled: entry.disabled === true ? true : void 0,
-				groups: Array.isArray(group?.groups) ? group.groups.map(word).filter(Boolean) : void 0,
+				groups: Array.isArray(group?.groups) ? group.groups.map(word$1).filter(Boolean) : void 0,
 				reaches: group?.coverage === void 0 ? void 0 : Object.keys(group.coverage).filter((model) => group.coverage[model] === true)
 			});
 		});
 	};
+	/** How this process reached PackyCode; a report never fails for want of it. */
+	const networkOf = async (secretList) => {
+		try {
+			return await network?.snapshot({ secrets: secretList });
+		} catch {
+			return;
+		}
+	};
 	return Object.freeze({
 		/** Recent top-level sessions, newest first, for the picker. */
 		async list(signal) {
-			return { sessions: (await query().listSessions(signal)).filter((record) => typeof record?.header?.id === "string" && !(record.header.delegationDepth > 0)).slice(0, SESSION_LIST_LIMIT).map((record) => compact({
+			return { sessions: (await query().listSessions(signal)).filter((record) => typeof record?.header?.id === "string" && !(record.header.delegationDepth > 0)).slice(0, SESSION_LIST_LIMIT).map((record) => compact$1({
 				id: record.header.id,
 				createdAt: iso(record.header.createdAt),
 				live: record.live === true,
@@ -6446,18 +6506,20 @@ function createDiagnostics({ sessionQuery, readEvents, ring, groups, secrets = a
 				throw new Error("PackyCode could not read that session");
 			}
 			const record = (await query().listSessions(signal)).find((item) => item?.header?.id === sessionId);
+			const secretList = await secrets();
 			return {
 				format: DIAGNOSTICS_FORMAT,
 				generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				plugin: compact({ version: await version() }),
-				session: compact({
+				plugin: compact$1({ version: await version() }),
+				session: compact$1({
 					id: sessionId,
 					createdAt: iso(record?.header?.createdAt),
 					live: record === void 0 ? void 0 : record.live === true,
 					delegationDepth: finite(record?.header?.delegationDepth)
 				}),
 				keys: await keys(),
-				...summarizeSessionEvents(events, { secrets: await secrets() })
+				...summarizeSessionEvents(events, { secrets: secretList }),
+				network: await networkOf(secretList)
 			};
 		}
 	});
@@ -7558,6 +7620,304 @@ function createModelSelectionController({ readPreference, writePreference, isWri
 	});
 }
 //#endregion
+//#region src/network.js
+/**
+* How this process reached PackyCode: how each request to the plugin's own
+* hosts ended at the transport level, which addresses a failed connection
+* tried and how each of them failed, and the runtime settings and name
+* resolution that decide those connections.
+*
+* Node's fetch reports every transport fault as a bare `fetch failed`, and
+* the OpenAI SDK turns that into "Connection error." or "Request timed out."
+* depending on which undici runs under fetch: the same connection, refused
+* after 0.5 s on every address, reads differently on two machines. undici
+* publishes the real cause on `diagnostics_channel`. This module listens
+* there for the plugin's hosts only and keeps identifiers and numbers: host
+* names, server addresses, paths without their query, error names and codes,
+* statuses and durations. It never reads headers or bodies.
+*
+* @module dsh-packycode-api/network
+*/
+/** How much the log keeps, and how long one host lookup may take. */
+const NETWORK_LIMITS = Object.freeze({
+	failures: 12,
+	samples: 50,
+	lookupMs: 3e3
+});
+const CHANNELS = Object.freeze({
+	create: "undici:request:create",
+	headers: "undici:request:headers",
+	error: "undici:request:error",
+	connected: "undici:client:connected",
+	connectError: "undici:client:connectError"
+});
+const NAME = /^[\w.:-]{1,60}$/u;
+const PATH = /^\/[\w.:/@%~+-]{0,79}$/u;
+const word = (value) => typeof value === "string" && NAME.test(value) ? value : void 0;
+const compact = (object) => Object.fromEntries(Object.entries(object).filter(([, value]) => value !== void 0));
+function hostnameOf(origin) {
+	try {
+		return new URL(String(origin)).hostname.toLowerCase();
+	} catch {
+		return;
+	}
+}
+/** The request path with its query dropped: a query may carry a credential. */
+function pathOf(path) {
+	const bare = typeof path === "string" ? path.split(/[?#]/u)[0] : void 0;
+	return bare !== void 0 && PATH.test(bare) ? bare : void 0;
+}
+/** A caller's cancellation, as opposed to a transport fault. */
+const isAbort$1 = (error) => error?.name === "AbortError" && typeof error?.code !== "string" || error?.code === "ABORT_ERR";
+/** `Name CODE` for the error and each cause under it. */
+function chainOf(error) {
+	const chain = [];
+	for (let current = error, depth = 0; current !== null && typeof current === "object" && depth < 3; current = current.cause, depth++) {
+		const label = [word(current.name) ?? word(current.constructor?.name), word(current.code)].filter(Boolean).join(" ");
+		if (label !== "") chain.push(label);
+	}
+	return chain.length === 0 ? void 0 : chain;
+}
+/** Each address a connection tried and how it failed, from the error or a cause under it. */
+function attemptsOf(error) {
+	const entry = (item) => net.isIP(item?.address ?? "") === 0 ? void 0 : [item.address, word(item.code)].filter(Boolean).join(" ");
+	for (let current = error, depth = 0; current !== null && typeof current === "object" && depth < 3; current = current.cause, depth++) {
+		if (Array.isArray(current.errors)) {
+			const list = current.errors.map(entry).filter(Boolean);
+			return list.length === 0 ? void 0 : list;
+		}
+		const single = entry(current);
+		if (single !== void 0) return [single];
+	}
+}
+function summary(samples) {
+	if (samples.length === 0) return void 0;
+	const sorted = [...samples].sort((a, b) => a - b);
+	const at = (share) => sorted[Math.min(sorted.length - 1, Math.floor(share * sorted.length))];
+	return {
+		median: at(.5),
+		p90: at(.9),
+		max: sorted.at(-1)
+	};
+}
+/** Which scheme each proxy variable names: lower case first, as DSH reads them. Never the proxy itself. */
+function proxySchemes(env) {
+	const read = (name) => {
+		const value = [env?.[name], env?.[name.toUpperCase()]].find((item) => typeof item === "string" && item.trim() !== "");
+		if (value === void 0) return void 0;
+		try {
+			return word(new URL(value.trim()).protocol.replace(/:$/u, "")) ?? "invalid";
+		} catch {
+			return "invalid";
+		}
+	};
+	const schemes = compact({
+		https: read("https_proxy"),
+		http: read("http_proxy"),
+		all: read("all_proxy"),
+		noProxy: read("no_proxy") === void 0 ? void 0 : true
+	});
+	return Object.keys(schemes).length === 0 ? "none" : schemes;
+}
+/** The settings that decide how Node opens a connection. */
+function runtimeOf(env) {
+	const call = (fn) => typeof fn === "function" ? fn() : void 0;
+	return compact({
+		node: process.version,
+		platform: process.platform,
+		autoSelectFamily: call(net.getDefaultAutoSelectFamily),
+		attemptTimeoutMs: call(net.getDefaultAutoSelectFamilyAttemptTimeout),
+		dnsOrder: call(dns.getDefaultResultOrder),
+		proxy: proxySchemes(env)
+	});
+}
+/** The addresses a connection to `hostname` would try, asked the way `net.connect` asks. */
+const defaultLookup = (hostname) => dns.promises.lookup(hostname, process.platform === "win32" ? { all: true } : {
+	all: true,
+	hints: dns.ADDRCONFIG
+});
+/**
+* The network log behind the diagnostics card.
+* @param options - the plugin's host origins (read on every request), the
+*   environment the proxy variables come from, and test seams for the clock,
+*   the lookup and its bound.
+*/
+function createNetworkLog({ hosts, env = process.env, now = Date.now, clock = () => performance.now(), lookupAll = defaultLookup, lookupMs = NETWORK_LIMITS.lookupMs } = {}) {
+	const watched = () => {
+		const names = [];
+		for (const origin of hosts?.() ?? []) {
+			const name = hostnameOf(origin);
+			if (name !== void 0 && !names.includes(name)) names.push(name);
+		}
+		return names;
+	};
+	const stats = /* @__PURE__ */ new Map();
+	const statsFor = (host) => {
+		let entry = stats.get(host);
+		if (entry === void 0) {
+			entry = {
+				requests: 0,
+				answered: 0,
+				statuses: {},
+				failed: {
+					connect: 0,
+					request: 0,
+					response: 0
+				},
+				aborted: 0,
+				headersMs: [],
+				connects: {
+					ok: 0,
+					afterFallback: 0,
+					ipv6: 0
+				}
+			};
+			stats.set(host, entry);
+		}
+		return entry;
+	};
+	const requests = /* @__PURE__ */ new WeakMap();
+	const connectErrors = /* @__PURE__ */ new WeakSet();
+	const failures = [];
+	let since;
+	let listening;
+	const guard = (handler) => (message) => {
+		try {
+			handler(message);
+		} catch {}
+	};
+	const handlers = {
+		[CHANNELS.create]: ({ request }) => {
+			const host = hostnameOf(request?.origin);
+			if (host === void 0 || !watched().includes(host)) return;
+			requests.set(request, {
+				host,
+				path: pathOf(request.path),
+				startedAt: clock(),
+				answered: false
+			});
+			statsFor(host).requests += 1;
+		},
+		[CHANNELS.headers]: ({ request, response }) => {
+			const entry = requests.get(request);
+			if (entry === void 0) return;
+			entry.answered = true;
+			const stat = statsFor(entry.host);
+			stat.answered += 1;
+			const status = response?.statusCode;
+			if (Number.isInteger(status)) stat.statuses[status] = (stat.statuses[status] ?? 0) + 1;
+			stat.headersMs.push(Math.round(clock() - entry.startedAt));
+			if (stat.headersMs.length > NETWORK_LIMITS.samples) stat.headersMs.shift();
+		},
+		[CHANNELS.connectError]: ({ error }) => {
+			if (error !== null && typeof error === "object") connectErrors.add(error);
+		},
+		[CHANNELS.connected]: ({ connectParams, socket }) => {
+			const host = typeof connectParams?.hostname === "string" ? connectParams.hostname.toLowerCase() : void 0;
+			if (host === void 0 || !watched().includes(host)) return;
+			const connects = statsFor(host).connects;
+			connects.ok += 1;
+			if (Array.isArray(socket?.autoSelectFamilyAttemptedAddresses) && socket.autoSelectFamilyAttemptedAddresses.length > 1) connects.afterFallback += 1;
+			if (socket?.remoteFamily === "IPv6") connects.ipv6 += 1;
+		},
+		[CHANNELS.error]: ({ request, error }) => {
+			const entry = requests.get(request);
+			if (entry === void 0) return;
+			requests.delete(request);
+			const stat = statsFor(entry.host);
+			if (isAbort$1(error)) {
+				stat.aborted += 1;
+				return;
+			}
+			const stage = connectErrors.has(error) ? "connect" : entry.answered ? "response" : "request";
+			stat.failed[stage] += 1;
+			failures.push(compact({
+				time: new Date(now()).toISOString(),
+				host: entry.host,
+				path: entry.path,
+				stage,
+				afterMs: Math.round(clock() - entry.startedAt),
+				error: chainOf(error),
+				attempts: attemptsOf(error),
+				message: typeof error?.message === "string" ? error.message.slice(0, 1e3) : void 0
+			}));
+			if (failures.length > NETWORK_LIMITS.failures) failures.shift();
+		}
+	};
+	const subscribed = Object.entries(handlers).map(([name, handler]) => [name, guard(handler)]);
+	const stop = () => {
+		if (!listening) return;
+		listening = false;
+		for (const [name, handler] of subscribed) unsubscribe(name, handler);
+	};
+	/** One host's addresses, or why there are none; never longer than `lookupMs`. */
+	const resolve = async (hostname) => {
+		let timer;
+		try {
+			const list = await Promise.race([lookupAll(hostname), new Promise((_, reject) => {
+				timer = setTimeout(() => reject(Object.assign(/* @__PURE__ */ new Error("lookup timed out"), { code: "LOOKUP_TIMEOUT" })), lookupMs);
+				timer.unref?.();
+			})]);
+			return { resolved: (Array.isArray(list) ? list : []).map((item) => item?.address).filter((address) => net.isIP(address ?? "") !== 0) };
+		} catch (error) {
+			return { lookupError: word(error?.code) ?? "LOOKUP_FAILED" };
+		} finally {
+			clearTimeout(timer);
+		}
+	};
+	const countsOf = (stat) => {
+		if (stat === void 0) return {};
+		const nonZero = (counts) => Object.fromEntries(Object.entries(counts).filter(([, count]) => count > 0));
+		const failed = nonZero(stat.failed);
+		return compact({
+			requests: stat.requests,
+			answered: stat.answered,
+			statuses: Object.keys(stat.statuses).length === 0 ? void 0 : { ...stat.statuses },
+			failed: Object.keys(failed).length === 0 ? void 0 : failed,
+			aborted: stat.aborted === 0 ? void 0 : stat.aborted,
+			headersMs: summary(stat.headersMs),
+			connects: stat.connects.ok === 0 ? void 0 : nonZero(stat.connects)
+		});
+	};
+	return Object.freeze({
+		/**
+		* Start listening; returns the function that stops it.
+		* @returns the disposer the plugin's effect runs on unload.
+		*/
+		start() {
+			if (!listening) {
+				listening = true;
+				since = now();
+				for (const [name, handler] of subscribed) subscribe(name, handler);
+			}
+			return stop;
+		},
+		stop,
+		/**
+		* What the log saw since it started, the runtime settings, and how each
+		* host resolves now.
+		* @param options - stored secrets to redact from error messages.
+		*/
+		async snapshot({ secrets = [] } = {}) {
+			const names = watched();
+			const lookups = await Promise.all(names.map(resolve));
+			return compact({
+				since: since === void 0 ? void 0 : new Date(since).toISOString(),
+				runtime: runtimeOf(env),
+				hosts: names.map((host, index) => ({
+					host,
+					...lookups[index],
+					...countsOf(stats.get(host))
+				})),
+				recentFailures: failures.map((failure) => compact({
+					...failure,
+					message: safeMessage$1(failure.message, secrets)
+				}))
+			});
+		}
+	});
+}
+//#endregion
 //#region src/claude-user-text.js
 /**
 * Which of DSH's messages Claude Code receives on the cc route.
@@ -7669,7 +8029,7 @@ function guardGeminiReplay(open, { model, context, signal, wait = waitForRetry }
 //#endregion
 //#region src/gemini-api.js
 /** Gemini's native API, including level-based thinking on older pi-ai hosts. */
-const GEMINI_MODELS = ["gemini-3.8-flash"];
+const GEMINI_MODELS = ["gemini-4-argon", "gemini-3.8-flash"];
 /**
 * Google's documented thought signature for a function call whose real one
 * cannot be sent: the API skips signature validation for it.
@@ -7723,10 +8083,10 @@ const skipped = (payload) => ({
 	contents: skipThoughtSignatures(payload.contents)
 });
 /**
-* pi-ai 0.85 defaults Flash to MINIMAL when reasoning is omitted. Flash
-* supports LOW/MEDIUM/HIGH, defaults to MEDIUM and cannot disable thinking.
-* Keep the native SDK stream, credentials and tools; correct that config and
-* send no real signature.
+* pi-ai 0.85 treats Argon as a budget-based model, and defaults Flash to
+* MINIMAL when reasoning is omitted. Both models support LOW/MEDIUM/HIGH,
+* default to MEDIUM and cannot disable thinking. Keep the native SDK stream,
+* credentials and tools; correct that config and send no real signature.
 */
 function createGeminiApi() {
 	const api = googleGenerativeAIApi();
@@ -7757,6 +8117,49 @@ function createGeminiApi() {
 	};
 }
 //#endregion
+//#region src/hy4-identity.js
+/** The sentence appended to Hy4's instructions; checked live as worded. */
+const HY4_IDENTITY_NOTE = "About yourself: the hy4 model is Hy4 from Tencent Hunyuan (腾讯混元), reached through PackyCode. DeepSeek Harness is the agent app you run in, not your model or its maker.";
+const INSTRUCTION_ROLES = /* @__PURE__ */ new Set(["developer", "system"]);
+const carriesNote = (item) => typeof item?.content === "string" && item.content.includes("About yourself: the hy4 model is Hy4 from Tencent Hunyuan (腾讯混元), reached through PackyCode. DeepSeek Harness is the agent app you run in, not your model or its maker.");
+/**
+* Add the note to a Responses payload: after the leading instructions, or as
+* the only ones when the request has none. A payload that already carries it
+* is returned unchanged, and the given payload is never modified.
+* @param payload - the Responses request body pi-ai built.
+* @returns the body to send.
+*/
+function withIdentityNote(payload) {
+	if (!Array.isArray(payload?.input) || payload.input.some(carriesNote)) return payload;
+	const [first, ...rest] = payload.input;
+	const input = INSTRUCTION_ROLES.has(first?.role) && typeof first.content === "string" ? [{
+		...first,
+		content: `${first.content}\n\n${HY4_IDENTITY_NOTE}`
+	}, ...rest] : [{
+		role: "developer",
+		content: HY4_IDENTITY_NOTE
+	}, ...payload.input];
+	return {
+		...payload,
+		input
+	};
+}
+/**
+* pi-ai options whose payload carries the note before any caller hook sees
+* it, so a caller's own `onPayload` still has the last word.
+* @param options - the request's pi-ai options.
+* @returns the same options with the note added on the way out.
+*/
+function withHy4Identity(options) {
+	return {
+		...options,
+		onPayload: async (payload, model) => {
+			const noted = withIdentityNote(payload);
+			return await options?.onPayload?.(noted, model) ?? noted;
+		}
+	};
+}
+//#endregion
 //#region src/provider.js
 /**
 * The PackyCode pi-ai provider, built in code so the user configures no route.
@@ -7812,10 +8215,13 @@ function createPackyCodeProvider({ claudeCli } = {}) {
 			"google-generative-ai": createGeminiApi()
 		}
 	});
-	const requestOptions = (model, options) => model.api === "openai-responses" && !model.id.startsWith("gpt-") ? {
-		...options,
-		cacheRetention: "none"
-	} : options;
+	const requestOptions = (model, options) => {
+		const cached = model.api === "openai-responses" && !model.id.startsWith("gpt-") ? {
+			...options,
+			cacheRetention: "none"
+		} : options;
+		return model.id === "hy4" ? withHy4Identity(cached) : cached;
+	};
 	return Object.freeze({
 		...provider,
 		stream: (model, context, options) => provider.stream(model, context, requestOptions(model, options)),
@@ -9460,6 +9866,17 @@ function apply(ctx, config) {
 			statusHost: normalizeHost(current.statusHost, DEFAULT_STATUS_HOST)
 		};
 	};
+	/**
+	* How requests to PackyCode's own hosts end at the transport level, for
+	* the diagnostics card. It listens from load, so the first group reading
+	* is in it too.
+	*/
+	const network = createNetworkLog({ hosts: () => [
+		hosts().apiHost,
+		DEFAULT_API_HOST,
+		...statusHostOrder(hosts())
+	] });
+	ctx.effect(() => network.start(), "packycode-api: network diagnostics");
 	const balance = createBalanceReader({
 		listKeys: () => ring.secrets(),
 		getHosts: hosts
@@ -9839,7 +10256,8 @@ function apply(ctx, config) {
 			ring,
 			groups,
 			secrets: async () => (await Promise.all([ring.secrets(), imageRing.secrets()])).flat().map((entry) => entry.key),
-			ownPackageJsonUrl: new URL("../package.json", import.meta.url)
+			ownPackageJsonUrl: new URL("../package.json", import.meta.url),
+			network
 		})
 	});
 	/**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-packycode-api",
-  "version": "1.4.4",
+  "version": "1.4.6",
   "description": "Use PackyCode API keys in DeepSeek Harness with multi-protocol models, image generation and editing, separate key rings, and balance display",
   "type": "module",
   "main": "./lib/index.js",