@chatcode/chatcode-cli 3.0.4-rc.2 → 3.0.4-rc.3

package/runtime/node_modules/@deepseek-ai/dsh-atomic-write/lib/index.js

@@ -1,6 +1,122 @@
 import { createHash, randomBytes } from "node:crypto";
-import { lstat, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
+import { link, lstat, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, win32 } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region lib/types/windows-lock.js
+/** Exclusive Windows inspection for an empty or zero-filled lock left by a failed creator. */
+const execute = promisify(execFile);
+/**
+* Read a small lock only when no other handle has the file open.
+* @param path - lock path, protected by the caller's takeover claim.
+* @returns its record, or undefined if exclusive access or inspection fails.
+*/
+async function readUnopenedWindowsLock(path) {
+	const powershell = win32.join(process.env.SystemRoot ?? "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+	const script = [
+		"$ErrorActionPreference = 'Stop'",
+		`$file = [IO.File]::Open('${path.replaceAll("'", "''")}', [IO.FileMode]::Open, [IO.FileAccess]::Read, [IO.FileShare]::None)`,
+		"try {",
+		"  if ($file.Length -gt 64) { exit 1 }",
+		"  $reader = [IO.StreamReader]::new($file, [Text.Encoding]::UTF8, $false)",
+		"  try { [Console]::Out.Write([Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($reader.ReadToEnd()))) }",
+		"  finally { $reader.Dispose() }",
+		"} finally { $file.Dispose() }"
+	].join("\n");
+	try {
+		const { stdout } = await execute(powershell, [
+			"-NoLogo",
+			"-NoProfile",
+			"-NonInteractive",
+			"-EncodedCommand",
+			Buffer.from(script, "utf16le").toString("base64")
+		], {
+			encoding: "utf8",
+			windowsHide: true,
+			timeout: 2e3,
+			maxBuffer: 4096,
+			env: Object.fromEntries(Object.entries(process.env).filter(([name]) => !/KEY|SECRET|TOKEN|PASSWORD/i.test(name)))
+		});
+		const value = stdout.trim();
+		const bytes = Buffer.from(value, "base64");
+		if (bytes.length > 64 || bytes.toString("base64") !== value) return void 0;
+		return bytes.toString("utf8");
+	} catch (error) {
+		return;
+	}
+}
+//#endregion
+//#region lib/types/linux-lock.js
+/** Linux writer identity and complete-record publication; other platforms retain PID records. */
+const RECORD = /^(\d+)\r?\n(?:linux ([a-f0-9-]{36}) (\d+) ([a-f0-9]{24})\n)?$/u;
+let ownIdentity;
+/** Read kernel identity without treating inaccessible procfs as evidence of an exited writer. */
+async function identity(pid) {
+	try {
+		const [boot, stat] = await Promise.all([readFile("/proc/sys/kernel/random/boot_id", "utf8"), readFile(`/proc/${pid}/stat`, "utf8")]);
+		const end = stat.lastIndexOf(")");
+		const start = end < 0 ? void 0 : stat.slice(end + 2).trim().split(/\s+/u)[19];
+		if (!/^[a-f0-9-]{36}$/u.test(boot.trim()) || start === void 0 || !/^\d+$/u.test(start)) return void 0;
+		return `${boot.trim()} ${start}`;
+	} catch (error) {
+		return;
+	}
+}
+/**
+* Render a new acquisition's record; Linux adds boot identity, start ticks, and a unique claim token.
+* @returns the PID record, with Linux identity when the kernel exposes it.
+*/
+async function writerLockRecord() {
+	const pid = `${process.pid}\n`;
+	if (process.platform !== "linux") return pid;
+	const current = await (ownIdentity ??= identity(process.pid));
+	return current === void 0 ? pid : `${pid}linux ${current} ${randomBytes(12).toString("hex")}\n`;
+}
+/**
+* Exclusively publish a complete Linux identity record, or create a legacy PID lock.
+* @param path - lock sibling in an existing parent directory.
+* @param record - one acquisition's record from writerLockRecord.
+*/
+async function createWriterLock(path, record) {
+	const nonce = RECORD.exec(record)?.[4];
+	if (process.platform !== "linux" || nonce === void 0) {
+		await writeFile(path, record, {
+			mode: 384,
+			flag: "wx"
+		});
+		return;
+	}
+	const temp = `${path}.${nonce}.tmp`;
+	try {
+		await writeFile(temp, record, {
+			mode: 384,
+			flag: "wx"
+		});
+		await link(temp, path);
+	} finally {
+		await rm(temp, { force: true });
+	}
+}
+/**
+* Determine whether a recorded writer exited, including Linux PID reuse and a previous boot.
+* @param record - untrusted contents of an existing lock file.
+* @returns true only for ESRCH or a different observable Linux process identity.
+*/
+async function writerExited(record) {
+	const match = RECORD.exec(record);
+	if (match === null) return false;
+	const pid = Number(match[1]);
+	if (pid === 0 || pid > 2147483647) return false;
+	if (pid !== process.pid) try {
+		process.kill(pid, 0);
+	} catch (error) {
+		return error.code === "ESRCH";
+	}
+	if (process.platform !== "linux" || match[2] === void 0) return false;
+	const current = await identity(pid);
+	return current !== void 0 && current !== `${match[2]} ${match[3]}`;
+}
+//#endregion
 //#region lib/types/index.js
 /**
 * Zero-dependency atomic file replacement and writer coordination.
@@ -8,38 +124,41 @@ import { dirname } from "node:path";
 * the caller's permission bits, then renames it over the target, so readers
 * observe either the old or the new complete content and a replaced file ends
 * up with exactly the stated mode. `withFileLock` serializes cross-process
-* writers of one file through a `wx`-created `<file>.lock` sibling, so a
+* writers of one file through an exclusively published `<file>.lock` sibling, so a
 * read-modify-write cycle can never resurrect a state another writer just
 * replaced; readers stay lock-free because the rename commit is atomic. A lock
-* whose recorded holder process no longer exists is taken over.
+* whose recorded holder process no longer exists is taken over. Windows also
+* recovers empty or zero-filled records after an exclusive read proves no
+* creator still has the lock file open. Linux records also distinguish
+* a previous boot or reused PID through kernel process identity.
 * @module @deepseek-ai/dsh-atomic-write
 */
-const WINDOWS_TRANSIENT_RENAME_ERRORS = new Set([
+const WINDOWS_TRANSIENT_FILE_ERRORS = new Set([
 	"EACCES",
 	"EBUSY",
 	"EPERM"
 ]);
-const WINDOWS_RENAME_RETRY_INITIAL_MS = 20;
-const WINDOWS_RENAME_RETRY_MAX_MS = 200;
-const WINDOWS_RENAME_RETRY_LIMIT = 8;
+const WINDOWS_FILE_RETRY_INITIAL_MS = 20;
+const WINDOWS_FILE_RETRY_MAX_MS = 200;
+const WINDOWS_FILE_RETRY_LIMIT = 8;
 /** Whether Windows reported temporary interference with an atomic replacement. */
-function isTransientWindowsRenameError(error) {
+function isTransientWindowsFileError(error) {
 	if (process.platform !== "win32") return false;
-	return WINDOWS_TRANSIENT_RENAME_ERRORS.has(error?.code ?? "");
+	return WINDOWS_TRANSIENT_FILE_ERRORS.has(error?.code ?? "");
 }
-/** Replace the target after bounded retries for transient Windows interference. */
-async function renameAtomicTemp(temp, filename) {
-	let delay = WINDOWS_RENAME_RETRY_INITIAL_MS;
+/** Retry a replacement or lock release while Windows briefly holds the path open. */
+async function retryWindowsFileOperation(operation) {
+	let delay = WINDOWS_FILE_RETRY_INITIAL_MS;
 	for (let retries = 0;; retries += 1) {
 		try {
-			await rename(temp, filename);
+			await operation();
 			return;
 		} catch (error) {
-			if (!isTransientWindowsRenameError(error)) throw error;
-			if (retries >= WINDOWS_RENAME_RETRY_LIMIT) throw error;
+			if (!isTransientWindowsFileError(error)) throw error;
+			if (retries >= WINDOWS_FILE_RETRY_LIMIT) throw error;
 		}
 		await new Promise((resolve) => setTimeout(resolve, delay));
-		delay = Math.min(delay * 2, WINDOWS_RENAME_RETRY_MAX_MS);
+		delay = Math.min(delay * 2, WINDOWS_FILE_RETRY_MAX_MS);
 	}
 }
 /**
@@ -69,7 +188,7 @@ async function writeFileAtomic(filename, content, options) {
 			mode: options.mode,
 			flag: "wx"
 		});
-		await renameAtomicTemp(temp, filename);
+		await retryWindowsFileOperation(() => rename(temp, filename));
 	} catch (error) {
 		await rm(temp, { force: true });
 		throw error;
@@ -87,18 +206,13 @@ async function isLockContention(error, lockPath) {
 		return false;
 	}
 }
-/** Whether the holder a `<pid>\n` record names is proven gone: a signal probe finds no such process. */
-function holderExited(record) {
-	if (!/^\d+\n$/.test(record)) return false;
-	const pid = Number(record.trim());
-	if (pid === 0 || pid > 2147483647) return false;
-	if (pid === process.pid) return false;
-	try {
-		process.kill(pid, 0);
-		return false;
-	} catch (error) {
-		return error.code === "ESRCH";
-	}
+/** Whether the recorded writer is absent or has a different observable Linux identity. */
+async function holderExited(record) {
+	return writerExited(record);
+}
+/** A crash can leave an empty or zero-filled record before the holder's PID reaches disk. */
+function damagedRecord(record) {
+	return record.length <= 64 && /^\0*$/.test(record);
 }
 /** The lock file's content, or undefined when it cannot be read. */
 async function readLockRecord(lockPath) {
@@ -109,18 +223,21 @@ async function readLockRecord(lockPath) {
 	}
 }
 /**
-* Remove the lock when its recorded holder exited. Contenders that read the
+* Remove an exited holder's lock or a closed, damaged Windows lock. Contenders that read the
 * same record serialize on a claim file named after it. Under the claim, the
 * claimant re-reads the lock and probes its PID again, and removes it only
-* when it still holds that record and that PID is still gone: the record's
+* when it still holds that record and that PID is still gone. A damaged Windows
+* record instead requires an exclusive read after claiming it. The record's
 * holder can no longer release it, and no other contender can remove it
 * without the claim, so a removal never deletes a lock another contender
 * acquired after the dead holder's, including one whose holder reused the PID.
-* @returns Whether this call removed the dead holder's lock.
+* @returns Whether this call removed the abandoned lock.
 */
 async function takeOverExitedLock(lockPath) {
 	const record = await readLockRecord(lockPath);
-	if (record === void 0 || !holderExited(record)) return false;
+	if (record === void 0) return false;
+	const damaged = process.platform === "win32" && damagedRecord(record);
+	if (!damaged && !await holderExited(record)) return false;
 	const claim = `${lockPath}.takeover-${createHash("sha256").update(record).digest("hex").slice(0, 16)}`;
 	try {
 		await writeFile(claim, `${process.pid}\n`, {
@@ -133,7 +250,10 @@ async function takeOverExitedLock(lockPath) {
 		throw error;
 	}
 	try {
-		if (await readLockRecord(lockPath) !== record || !holderExited(record)) return false;
+		if (await readLockRecord(lockPath) !== record) return false;
+		if (damaged) {
+			if (await readUnopenedWindowsLock(lockPath) !== record) return false;
+		} else if (!await holderExited(record)) return false;
 		try {
 			await rm(lockPath, { force: true });
 		} catch (error) {
@@ -163,7 +283,7 @@ const LOCK_RETRY_MAX_MS = 200;
 const DEFAULT_LOCK_WAIT_MS = 2e3;
 /**
 * Hold the cross-process writer lock for `filename` around one operation. The
-* lock is a `wx`-created sibling (`<filename>.lock`); paired with the
+* lock is an exclusively published sibling (`<filename>.lock`); paired with the
 * rename-based commit of {@link writeFileAtomic}, readers stay lock-free and
 * only writers contend. `EEXIST` is contention directly; an `EPERM` is
 * contention only when a fresh `lstat` confirms the lock path exists, covering
@@ -172,9 +292,14 @@ const DEFAULT_LOCK_WAIT_MS = 2e3;
 * permission error is rethrown. The lock records its holder's PID. A contender
 * removes the lock and retries at once when no process with that PID exists
 * (`ESRCH`); any other lock, including one whose holder exists under another
-* user (`EPERM`) or whose record is incomplete, is waited for. Contention backs
-* off exponentially and times out after the deadline. A holder whose PID a
-* live process reused keeps its lock until an operator removes it. Takeover
+* user (`EPERM`) or whose record is incomplete, is waited for. On Windows,
+* empty or zero-filled records of at most 64 bytes can also be recovered after
+* exclusive inspection proves no creator still has the file open. A failed
+* inspection preserves the lock. Windows lock release retries transient file
+* interference for a bounded interval. Contention backs
+* off exponentially and times out after the deadline. Linux identity records
+* distinguish PID reuse and a previous boot; legacy PID-only records cannot.
+* Missing or inaccessible identity metadata never authorizes takeover. Takeover
 * proves only that the recorded process exited: an operation that starts other
 * writers must stop them with it or leave its successor a way to find them.
 * PIDs are compared on the contender's host, so writers on other hosts or in
@@ -187,15 +312,13 @@ const DEFAULT_LOCK_WAIT_MS = 2e3;
 */
 async function withFileLock(filename, operation, options) {
 	const lockPath = `${filename}.lock`;
+	const record = await writerLockRecord();
 	const deadline = Date.now() + (options?.waitMs ?? DEFAULT_LOCK_WAIT_MS);
 	let delay = LOCK_RETRY_INITIAL_MS;
 	let retriedUnconfirmedPermissionError = false;
 	for (;;) {
 		try {
-			await writeFile(lockPath, `${process.pid}\n`, {
-				mode: 384,
-				flag: "wx"
-			});
+			await createWriterLock(lockPath, record);
 			break;
 		} catch (error) {
 			if (!await isLockContention(error, lockPath)) {
@@ -210,7 +333,7 @@ async function withFileLock(filename, operation, options) {
 	try {
 		return await operation();
 	} finally {
-		await rm(lockPath, { force: true });
+		await retryWindowsFileOperation(() => rm(lockPath, { force: true }));
 	}
 }
 //#endregion

package/runtime/node_modules/@deepseek-ai/dsh-atomic-write/lib/types/index.d.ts

@@ -4,10 +4,13 @@
  * the caller's permission bits, then renames it over the target, so readers
  * observe either the old or the new complete content and a replaced file ends
  * up with exactly the stated mode. `withFileLock` serializes cross-process
- * writers of one file through a `wx`-created `<file>.lock` sibling, so a
+ * writers of one file through an exclusively published `<file>.lock` sibling, so a
  * read-modify-write cycle can never resurrect a state another writer just
  * replaced; readers stay lock-free because the rename commit is atomic. A lock
- * whose recorded holder process no longer exists is taken over.
+ * whose recorded holder process no longer exists is taken over. Windows also
+ * recovers empty or zero-filled records after an exclusive read proves no
+ * creator still has the lock file open. Linux records also distinguish
+ * a previous boot or reused PID through kernel process identity.
  * @module @deepseek-ai/dsh-atomic-write
  */
 /**
@@ -58,7 +61,7 @@ export interface FileLockOptions {
 }
 /**
  * Hold the cross-process writer lock for `filename` around one operation. The
- * lock is a `wx`-created sibling (`<filename>.lock`); paired with the
+ * lock is an exclusively published sibling (`<filename>.lock`); paired with the
  * rename-based commit of {@link writeFileAtomic}, readers stay lock-free and
  * only writers contend. `EEXIST` is contention directly; an `EPERM` is
  * contention only when a fresh `lstat` confirms the lock path exists, covering
@@ -67,9 +70,14 @@ export interface FileLockOptions {
  * permission error is rethrown. The lock records its holder's PID. A contender
  * removes the lock and retries at once when no process with that PID exists
  * (`ESRCH`); any other lock, including one whose holder exists under another
- * user (`EPERM`) or whose record is incomplete, is waited for. Contention backs
- * off exponentially and times out after the deadline. A holder whose PID a
- * live process reused keeps its lock until an operator removes it. Takeover
+ * user (`EPERM`) or whose record is incomplete, is waited for. On Windows,
+ * empty or zero-filled records of at most 64 bytes can also be recovered after
+ * exclusive inspection proves no creator still has the file open. A failed
+ * inspection preserves the lock. Windows lock release retries transient file
+ * interference for a bounded interval. Contention backs
+ * off exponentially and times out after the deadline. Linux identity records
+ * distinguish PID reuse and a previous boot; legacy PID-only records cannot.
+ * Missing or inaccessible identity metadata never authorizes takeover. Takeover
  * proves only that the recorded process exited: an operation that starts other
  * writers must stop them with it or leave its successor a way to find them.
  * PIDs are compared on the contender's host, so writers on other hosts or in

package/runtime/node_modules/@deepseek-ai/dsh-atomic-write/lib/types/linux-lock.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Render a new acquisition's record; Linux adds boot identity, start ticks, and a unique claim token.
+ * @returns the PID record, with Linux identity when the kernel exposes it.
+ */
+export declare function writerLockRecord(): Promise<string>;
+/**
+ * Exclusively publish a complete Linux identity record, or create a legacy PID lock.
+ * @param path - lock sibling in an existing parent directory.
+ * @param record - one acquisition's record from writerLockRecord.
+ */
+export declare function createWriterLock(path: string, record: string): Promise<void>;
+/**
+ * Determine whether a recorded writer exited, including Linux PID reuse and a previous boot.
+ * @param record - untrusted contents of an existing lock file.
+ * @returns true only for ESRCH or a different observable Linux process identity.
+ */
+export declare function writerExited(record: string): Promise<boolean>;
+//# sourceMappingURL=linux-lock.d.ts.map

package/runtime/node_modules/@deepseek-ai/dsh-atomic-write/lib/types/windows-lock.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Read a small lock only when no other handle has the file open.
+ * @param path - lock path, protected by the caller's takeover claim.
+ * @returns its record, or undefined if exclusive access or inspection fails.
+ */
+export declare function readUnopenedWindowsLock(path: string): Promise<string | undefined>;
+//# sourceMappingURL=windows-lock.d.ts.map

package/runtime/node_modules/@deepseek-ai/dsh-client-ui-settings-account/lib/client.js

@@ -4125,7 +4125,7 @@ window.__ModuleLoader__.load({
 				for (const listener of listeners) listener();
 			};
 			/** @returns the client identity for one account call, read at call time so it carries the language and zone in effect then. */
-			const client = () => accountClientMetadata(ctx.locale.getSnapshot().active, "3.0.4-rc.2");
+			const client = () => accountClientMetadata(ctx.locale.getSnapshot().active, "3.0.4-rc.3");
 			const notices = createBonusNoticeController({
 				ackRetryDelayMs: config.bonusAckRetryDelayMs,
 				ackRetryMaxDelayMs: config.bonusAckRetryMaxDelayMs,
@@ -4256,7 +4256,7 @@ window.__ModuleLoader__.load({
 				refreshAccount,
 				contactUs() {
 					const url = contactUrl(config, {
-						version: "3.0.4-rc.2",
+						version: "3.0.4-rc.3",
 						locale: ctx.locale.getSnapshot().active === "zh" ? "zh-CN" : "en",
 						width: window.screen.width,
 						height: window.screen.height,

package/runtime/node_modules/@deepseek-ai/dsh-client-ui-settings-general/lib/client.js

@@ -657,7 +657,7 @@ window.__ModuleLoader__.load({
 		function CurrentVersionRow({ t }) {
 			return (0, react_jsx_runtime.jsx)("div", {
 				className: CurrentVersionRow_module_css_default.row,
-				children: t("general.currentVersion", { version: "3.0.4-rc.2" })
+				children: t("general.currentVersion", { version: "3.0.4-rc.3" })
 			});
 		}
 		//#endregion

package/runtime/node_modules/@deepseek-ai/dsh-client-ui-sidebar/lib/client.js

@@ -167,9 +167,7 @@ window.__ModuleLoader__.load({
 		const SCROLLBAR_LINGER_MS = 2e3;
 		/** Format complete-build metadata for the local brand badge. */
 		function localBuildVersion() {
-			const commit = "4d610ce";
-			const dirty = {}.CHATCODE_CLI_CLIENT_GIT_DIRTY ?? {}["DSH_CLIENT_GIT_DIRTY"];
-			return `3.0.4-rc.2-${commit}` + (dirty === "true" ? "-dirty" : "");
+			return `3.0.4-rc.3-4d610ce-dirty`;
 		}
 		/** Each panel row subscribes only to its own selection state. */
 		function PanelRow({ id, label, wide, usePanelInfo, selectPanel, renderSlot }) {

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek/lib/types/adapter.d.ts

@@ -13,7 +13,7 @@ export declare class DeepSeekAdapter<C extends Connection = Connection> extends
         name: string;
     };
     providerRetryPolicy(_provider: string): import("@deepseek-ai/dsh-llm").ResolvedRetryPolicy;
-    listModels(provider: string): Promise<import("@deepseek-ai/dsh-llm").LlmModelInfo[] | never[]>;
+    listModels(provider: string): Promise<never[] | import("@deepseek-ai/dsh-llm").LlmModelInfo[]>;
     resolveModel(provider: string, model: string, _signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-llm").LlmResolvedModelInfo>;
     imageRequestPricing(_provider: string, model: string): import("@deepseek-ai/dsh-llm").LlmImageRequestPricing;
     prepareCall(provider: string, model: string, _signal?: AbortSignal): Promise<PreparedAdapterCall>;

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek/lib/types/config.d.ts

@@ -56,7 +56,7 @@ export declare function plainOptions(config: Config): Options;
 export declare const deepSeekConfigFields: {
     baseURL: z<string, string, "volatile">;
     thinking: z<"enabled" | "disabled", "enabled" | "disabled", "volatile">;
-    reasoningEffort: z<"off" | "low" | "high" | "max", "off" | "low" | "high" | "max", "volatile">;
+    reasoningEffort: z<"low" | "off" | "high" | "max", "low" | "off" | "high" | "max", "volatile">;
     maxTokens: z<number, number, "volatile-defined">;
     defaultContextWindow: z<number, number, "volatile-defined">;
     models: z<NoInfer<DeepSeekCatalogModel[]>, NoInfer<DeepSeekCatalogModel[]>, "volatile-defined">;
@@ -76,7 +76,7 @@ export declare const deepSeekConfigFields: {
 export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     baseURL: z<string, string, "volatile">;
     thinking: z<"enabled" | "disabled", "enabled" | "disabled", "volatile">;
-    reasoningEffort: z<"off" | "low" | "high" | "max", "off" | "low" | "high" | "max", "volatile">;
+    reasoningEffort: z<"low" | "off" | "high" | "max", "low" | "off" | "high" | "max", "volatile">;
     maxTokens: z<number, number, "volatile-defined">;
     defaultContextWindow: z<number, number, "volatile-defined">;
     models: z<NoInfer<DeepSeekCatalogModel[]>, NoInfer<DeepSeekCatalogModel[]>, "volatile-defined">;
@@ -95,7 +95,7 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
 }>>, Schemastery.ObjectT<NoInfer<{
     baseURL: z<string, string, "volatile">;
     thinking: z<"enabled" | "disabled", "enabled" | "disabled", "volatile">;
-    reasoningEffort: z<"off" | "low" | "high" | "max", "off" | "low" | "high" | "max", "volatile">;
+    reasoningEffort: z<"low" | "off" | "high" | "max", "low" | "off" | "high" | "max", "volatile">;
     maxTokens: z<number, number, "volatile-defined">;
     defaultContextWindow: z<number, number, "volatile-defined">;
     models: z<NoInfer<DeepSeekCatalogModel[]>, NoInfer<DeepSeekCatalogModel[]>, "volatile-defined">;

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek-account/lib/types/config.d.ts

@@ -5,7 +5,7 @@ export type Config = ProtocolConfig;
 export declare const Config: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<NoInfer<{
     baseURL: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
     thinking: import("@deepseek-ai/schemastery").default<"enabled" | "disabled", "enabled" | "disabled", "volatile">;
-    reasoningEffort: import("@deepseek-ai/schemastery").default<"off" | "low" | "high" | "max", "off" | "low" | "high" | "max", "volatile">;
+    reasoningEffort: import("@deepseek-ai/schemastery").default<"low" | "off" | "high" | "max", "low" | "off" | "high" | "max", "volatile">;
     maxTokens: import("@deepseek-ai/schemastery").default<number, number, "volatile-defined">;
     defaultContextWindow: import("@deepseek-ai/schemastery").default<number, number, "volatile-defined">;
     models: import("@deepseek-ai/schemastery").default<NoInfer<import("@deepseek-ai/dsh-llm-deepseek").DeepSeekCatalogModel[]>, NoInfer<import("@deepseek-ai/dsh-llm-deepseek").DeepSeekCatalogModel[]>, "volatile-defined">;
@@ -24,7 +24,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
 }>>, Schemastery.ObjectT<NoInfer<{
     baseURL: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
     thinking: import("@deepseek-ai/schemastery").default<"enabled" | "disabled", "enabled" | "disabled", "volatile">;
-    reasoningEffort: import("@deepseek-ai/schemastery").default<"off" | "low" | "high" | "max", "off" | "low" | "high" | "max", "volatile">;
+    reasoningEffort: import("@deepseek-ai/schemastery").default<"low" | "off" | "high" | "max", "low" | "off" | "high" | "max", "volatile">;
     maxTokens: import("@deepseek-ai/schemastery").default<number, number, "volatile-defined">;
     defaultContextWindow: import("@deepseek-ai/schemastery").default<number, number, "volatile-defined">;
     models: import("@deepseek-ai/schemastery").default<NoInfer<import("@deepseek-ai/dsh-llm-deepseek").DeepSeekCatalogModel[]>, NoInfer<import("@deepseek-ai/dsh-llm-deepseek").DeepSeekCatalogModel[]>, "volatile-defined">;

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek-api-key/lib/types/config.d.ts

@@ -14,7 +14,7 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     apiKeyEnv: z<string, string, "volatile-defined">;
     baseURL: z<string, string, "volatile">;
     thinking: z<"enabled" | "disabled", "enabled" | "disabled", "volatile">;
-    reasoningEffort: z<"off" | "low" | "high" | "max", "off" | "low" | "high" | "max", "volatile">;
+    reasoningEffort: z<"low" | "off" | "high" | "max", "low" | "off" | "high" | "max", "volatile">;
     maxTokens: z<number, number, "volatile-defined">;
     defaultContextWindow: z<number, number, "volatile-defined">;
     models: z<NoInfer<import("@deepseek-ai/dsh-llm-deepseek").DeepSeekCatalogModel[]>, NoInfer<import("@deepseek-ai/dsh-llm-deepseek").DeepSeekCatalogModel[]>, "volatile-defined">;
@@ -34,7 +34,7 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     apiKeyEnv: z<string, string, "volatile-defined">;
     baseURL: z<string, string, "volatile">;
     thinking: z<"enabled" | "disabled", "enabled" | "disabled", "volatile">;
-    reasoningEffort: z<"off" | "low" | "high" | "max", "off" | "low" | "high" | "max", "volatile">;
+    reasoningEffort: z<"low" | "off" | "high" | "max", "low" | "off" | "high" | "max", "volatile">;
     maxTokens: z<number, number, "volatile-defined">;
     defaultContextWindow: z<number, number, "volatile-defined">;
     models: z<NoInfer<import("@deepseek-ai/dsh-llm-deepseek").DeepSeekCatalogModel[]>, NoInfer<import("@deepseek-ai/dsh-llm-deepseek").DeepSeekCatalogModel[]>, "volatile-defined">;

package/runtime/node_modules/@deepseek-ai/dsh-tool-cordis/lib/types/api-catalog.js

@@ -4741,7 +4741,7 @@ export const TYPE_API = [
     },
     {
         name: 'CommandInputDescriptor',
-        declaration: 'export interface CommandInputDescriptor {\n    readonly hint: string;\n    readonly attachments?: boolean;\n}',
+        declaration: 'export interface CommandInputDescriptor {\n    readonly hint: string;\n    readonly suggestions?: readonly {\n        readonly value: string;\n        readonly description: string;\n    }[];\n    readonly attachments?: boolean;\n}',
     },
     {
         name: 'CommandInvocation',

package/scripts/launch.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import { readFileSync } from 'node:fs'
+import { enableCompileCache } from 'node:module'
 import { dirname, join, resolve } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import { registerEmbeddedRuntime } from './register-embedded-runtime.mjs'
@@ -8,6 +9,13 @@ import { registerEmbeddedRuntime } from './register-embedded-runtime.mjs'
 const packageDir = resolve(dirname(fileURLToPath(import.meta.url)), '..')
 const manifest = JSON.parse(readFileSync(join(packageDir, 'package.json'), 'utf8'))
 
+// Cache the installed module graph before its first import. Node owns cache
+// permissions, NODE_COMPILE_CACHE and NODE_DISABLE_COMPILE_CACHE handling.
+try { enableCompileCache() } catch (error) {
+  // A restricted filesystem must not prevent launching without the optional cache.
+  void error
+}
+
 // Register before loading the CLI's static imports. Global installations may
 // belong to root; launching must not rewrite their dependency directories.
 if (!manifest.dependencies?.['@deepseek-ai/dsh-app-boot']?.startsWith('workspace:')) {