@deepseek-ai/dsh-ptc-runtime-node 0.2.1-alpha.2 → 0.2.1-alpha.4

package/lib/process.js

@@ -943,16 +943,16 @@ function wireReplies(port, pending) {
 * @param port - the port binding calls are posted to.
 * @param pending - the id-keyed map each posted call parks its handles in.
 * @param nextId - the shared mutable id counter (program-issued correlation ids).
-* @param errorClasses - per-namespace constructors shared with program globals.
+* @param errorClasses - Namespace constructors shared with program globals, resolved for each invocation.
 * @returns one namespace object per declaration, in declaration order.
 */
 function makeNamespaces(data, port, pending, nextId, errorClasses = makeBindingErrorClasses(data)) {
 	return data.namespaces.map(({ global, names }) => {
-		const errorClass = errorClasses.get(global);
 		const namespace = Object.create(null);
 		for (const name of names) Object.defineProperty(namespace, name, {
 			enumerable: true,
 			value: (args) => {
+				const errorClass = errorClasses.get(global);
 				let detached;
 				try {
 					detached = snapshotPtcJsonValue(args);
@@ -961,7 +961,7 @@ function makeNamespaces(data, port, pending, nextId, errorClasses = makeBindingE
 				}
 				if (detached === void 0) return Promise.reject(bindingFailure(errorClass, name, "binding arguments must be lossless JSON"));
 				return new Promise((resolve, reject) => {
-					const id = nextId.value++;
+					const id = nextId.value;
 					pending.set(id, {
 						resolve,
 						reject: (error) => {
@@ -976,9 +976,10 @@ function makeNamespaces(data, port, pending, nextId, errorClasses = makeBindingE
 							name,
 							args: encodePtcJsonWire(detached)
 						});
+						nextId.value += 1;
 					} catch (error) {
 						pending.delete(id);
-						reject(bindingFailure(errorClass, name, `binding arguments must be structured-cloneable: ${error instanceof CapturedError ? error.message : String(error)}`));
+						reject(bindingFailure(errorClass, name, `binding call could not be sent: ${error instanceof CapturedError ? error.message : String(error)}`));
 					}
 				});
 			}
@@ -1049,6 +1050,14 @@ const STARTUP_ENVIRONMENT_NAMES = new Set([
 	"TEMP",
 	"TMP"
 ]);
+/**
+* Clear inherited credentials while preserving native child-process startup paths.
+* @param state - Child process environment, replaced with an empty program-visible object.
+*/
+function clearProgramEnvironment(state) {
+	for (const key of Object.keys(state.env)) if (!STARTUP_ENVIRONMENT_NAMES.has(key.toUpperCase())) Reflect.deleteProperty(state.env, key);
+	state.env = Object.create(null);
+}
 //#endregion
 //#region lib/types/process.js
 /**
@@ -1060,8 +1069,7 @@ const STARTUP_ENVIRONMENT_NAMES = new Set([
 */
 async function runNodeMain(stream, maxMessageBytes, processState) {
 	if (!Number.isSafeInteger(maxMessageBytes) || maxMessageBytes <= 0 || maxMessageBytes > 4294967295) throw new Error("invalid control message limit");
-	for (const key of Object.keys(processState.env)) if (!STARTUP_ENVIRONMENT_NAMES.has(key.toUpperCase())) Reflect.deleteProperty(processState.env, key);
-	processState.env = Object.create(null);
+	clearProgramEnvironment(processState);
 	const boot = Promise.withResolvers();
 	const listeners = [];
 	let started = false;

package/lib/types/bindings.d.ts

@@ -1,8 +1,17 @@
-import type { PtcBindingNamespace, PtcRunRequest } from '@deepseek-ai/dsh-ptc-runtime';
+import type { PtcBindingFunction, PtcBindingNamespace, PtcJsonValue, PtcRunRequest } from '@deepseek-ai/dsh-ptc-runtime';
+import type { ReplyMessage } from './protocol.ts';
 /**
  * Reject unusable namespaces before starting a process.
  * @param request - Host-owned binding declarations.
  * @returns Namespaces keyed by their declared global.
  */
 export declare function validateBindings(request: PtcRunRequest): Map<string, PtcBindingNamespace>;
+/**
+ * Invoke a host binding and encode its lossless result or bounded-channel rejection.
+ * @param id - Program-issued correlation identifier.
+ * @param binding - Current evaluation's declared function, absent if it was removed.
+ * @param args - Validated JSON arguments detached from the program.
+ * @returns A reply suitable for the runtime's bounded control channel.
+ */
+export declare function replyToBinding(id: number, binding: PtcBindingFunction | undefined, args: PtcJsonValue): Promise<ReplyMessage>;
 //# sourceMappingURL=bindings.d.ts.map

package/lib/types/bootstrap.d.ts

@@ -52,7 +52,7 @@ declare const CONSOLE_LEVELS: readonly ["log", "info", "warn", "error", "debug"]
  * @param logs - the buffer every rendered line is pushed into.
  * @returns the five-method console object handed to the program.
  */
-export declare function makeConsoleShim(logs: LogBuffer): Record<(typeof CONSOLE_LEVELS)[number], (...args: unknown[]) => void>;
+export declare function makeConsoleShim(logs: Pick<LogBuffer, 'push'>): Record<(typeof CONSOLE_LEVELS)[number], (...args: unknown[]) => void>;
 /**
  * Redirect a stream's `write` into the log buffer (the program-visible
  * `process.stdout`/`process.stderr` in the Node child), so raw writes land in emission order
@@ -65,7 +65,7 @@ export declare function makeConsoleShim(logs: LogBuffer): Record<(typeof CONSOLE
  * @returns the restore function (the in-process tests un-patch; the real
  *   child never needs to).
  */
-export declare function captureStreamWrites(logs: LogBuffer, stream: PatchableStream): () => void;
+export declare function captureStreamWrites(logs: Pick<LogBuffer, 'push'>, stream: PatchableStream): () => void;
 /**
  * Prepare the program's completion value for the done message. Only lossless
  * JSON crosses, and a value that does not fit the remaining combined outer
@@ -94,6 +94,15 @@ export interface PendingCall {
 }
 /** Constructor type for one program-visible binding rejection class. */
 export type BindingErrorConstructor = new (memberName: string, message: string) => Error;
+/**
+ * Materialize the real error constructor declared by one namespace.
+ * @param descriptor - program-global class name and member-name property.
+ * @returns the constructor injected into the program and used for rejections.
+ */
+export declare function makeBindingErrorClass(descriptor: {
+    name: string;
+    memberNameProperty: string;
+}): BindingErrorConstructor;
 /**
  * Build each declared error class once so calls and `instanceof` share constructor identity.
  * @param data - binding namespace declarations from the boot payload.
@@ -121,12 +130,12 @@ export declare function wireReplies(port: BootstrapPort, pending: Map<number, Pe
  * @param port - the port binding calls are posted to.
  * @param pending - the id-keyed map each posted call parks its handles in.
  * @param nextId - the shared mutable id counter (program-issued correlation ids).
- * @param errorClasses - per-namespace constructors shared with program globals.
+ * @param errorClasses - Namespace constructors shared with program globals, resolved for each invocation.
  * @returns one namespace object per declaration, in declaration order.
  */
 export declare function makeNamespaces(data: Pick<ProgramBootData, 'namespaces'>, port: BootstrapPort, pending: Map<number, PendingCall>, nextId: {
     value: number;
-}, errorClasses?: Map<string, BindingErrorConstructor>): Record<string, unknown>[];
+}, errorClasses?: Pick<ReadonlyMap<string, BindingErrorConstructor>, 'get'>): Record<string, unknown>[];
 /**
  * Run one strict async-function body, allowing top-level `await` and `return`, and post exactly
  * one terminal {@link DoneMessage}; a thrown program error becomes its `error` field.

package/lib/types/config.d.ts

@@ -0,0 +1,34 @@
+/** Execution mode and resource limits for the Node PTC provider. */
+import z from '@deepseek-ai/schemastery';
+import type { LaunchConfig } from './launch.ts';
+/** Deployment-varying runtime bounds and launch choices. */
+export interface Config {
+    /** Worker invocation in the subprocess world; omitted selects the local carrier. */
+    launch?: LaunchConfig;
+    /** per-call starts fresh processes; persistent-in-memory retains a REPL per owner under the same file policy. */
+    executionMode?: 'per-call' | 'persistent-in-memory';
+    /** Default elapsed deadline, including nested tool and approval waits. */
+    timeoutMs?: number;
+    /** Maximum numeric elapsed budget accepted by resolve. */
+    maxTimeoutMs?: number;
+    /** Combined serialized logs, completion and diagnostic byte cap. */
+    maxOutputBytes?: number;
+    /** V8 old-generation heap limit in MiB; native allocations are excluded. */
+    maxOldGenerationSizeMb?: number;
+    /** Maximum control frame, outstanding argument and queued control-output bytes. */
+    maxMessageBytes?: number;
+    /** Maximum simultaneous host binding calls accepted from a program. */
+    maxPendingCalls?: number;
+    /** Managed process termination and output-drain grace in milliseconds. */
+    graceMs?: number;
+}
+/** Configuration after Loader defaults and executable selection. */
+export type ResolvedConfig = Required<Config>;
+/** Loader defaults for the Node PTC provider. */
+export declare const NodeConfig: z<Config>;
+/**
+ * Validate resolved Node limits and paths.
+ * @param config - Loader-defaulted fields with the selected executable.
+ */
+export declare function validateConfig(config: ResolvedConfig): void;
+//# sourceMappingURL=config.d.ts.map

package/lib/types/environment.d.ts

@@ -1,4 +1,11 @@
 /** Startup variables required by native executables before model evaluation. */
 /** Native executable search, Windows system paths, and sandbox temporary paths retained in the OS environment. */
 export declare const STARTUP_ENVIRONMENT_NAMES: ReadonlySet<string>;
+/**
+ * Clear inherited credentials while preserving native child-process startup paths.
+ * @param state - Child process environment, replaced with an empty program-visible object.
+ */
+export declare function clearProgramEnvironment(state: {
+    env: NodeJS.ProcessEnv;
+}): void;
 //# sourceMappingURL=environment.d.ts.map

package/lib/types/index.d.ts

@@ -1,55 +1,41 @@
 import { Context } from '@deepseek-ai/cordis';
-import z from '@deepseek-ai/schemastery';
 import { PtcRuntime } from '@deepseek-ai/dsh-ptc-runtime';
 import type { PtcRunRequest, PtcRunResult, PtcRunSpec } from '@deepseek-ai/dsh-ptc-runtime';
 import type { SandboxMode } from '@deepseek-ai/dsh-sandbox';
-import type { LaunchConfig } from './launch.ts';
+import type { Config } from './config.ts';
+export type { Config } from './config.ts';
 export type { LaunchConfig } from './launch.ts';
-/** Deployment-varying runtime bounds and launch choices. */
-export interface Config {
-    /** Worker invocation in the subprocess world; omitted selects the local carrier. */
-    launch?: LaunchConfig;
-    /** Default elapsed deadline, including nested tool and approval waits. */
-    timeoutMs?: number;
-    /** Maximum numeric elapsed budget accepted by resolve. */
-    maxTimeoutMs?: number;
-    /** Combined serialized logs, completion and diagnostic byte cap. */
-    maxOutputBytes?: number;
-    /** V8 old-generation heap limit in MiB; native allocations are excluded. */
-    maxOldGenerationSizeMb?: number;
-    /** Maximum control frame, outstanding argument and queued control-output bytes. */
-    maxMessageBytes?: number;
-    /** Maximum simultaneous host binding calls accepted from a program. */
-    maxPendingCalls?: number;
-    /** Managed process termination and output-drain grace in milliseconds. */
-    graceMs?: number;
-}
-/** Node provider; direct file effects use the same sandbox service as Bash. */
+/** Node execution under file policy, with optional owner-scoped retained memory. */
 export declare class NodePtcRuntime extends PtcRuntime {
     static inject: string[];
-    static Config: z<Config>;
+    static Config: import("@deepseek-ai/schemastery").default<Config>;
     readonly language = "typescript";
     readonly isolation = "process";
+    private readonly inMemory?;
+    private readonly processes;
+    get programFormat(): 'function-body' | 'repl';
     get executionInstructions(): string;
     private readonly config;
     private readonly live;
     private disposed;
     constructor(ctx: Context, config: Config);
-    get sandboxMode(): SandboxMode;
+    get sandboxMode(): SandboxMode | undefined;
+    release(owner: object): Promise<void>;
     get timeout(): {
         defaultMs: number;
         maxMs: number;
     };
     /**
-     * Resolve an execution under explicit or deployment policy.
+     * Resolve directory, deadline and file policy for the selected execution mode.
      * @param request - Program, bindings, optional cwd/deadline, and resolved authority.
      * @returns Complete execution inputs with a capped numeric budget or an explicit null deadline.
      */
     resolve(request: PtcRunRequest): PtcRunSpec;
     /**
-     * Run a resolved program in a fresh managed and confined Node process.
-     * @param spec - Inputs returned by resolve; missing authority is caller misuse.
-     * @returns Output and file-confinement facts after managed cleanup.
+     * Run a resolved program under the configured execution mode.
+     * Session mode changes cancel admitted calls before process launch as well as active programs.
+     * @param spec - Inputs returned by resolve for the configured mode.
+     * @returns Logs, JSON completion or failure; retained processes remain until release or invalidation.
      */
     run(spec: PtcRunSpec): Promise<PtcRunResult>;
     private execute;

package/lib/types/launch.d.ts

@@ -24,7 +24,8 @@ export declare function resolveLaunch(config?: LaunchConfig): LaunchConfig;
  * @param fs - Filesystem mapping host bootstrap assets into the process world.
  * @param config - resolved worker invocation.
  * @param maxMessageBytes - Validated frame and queued-write limit.
+ * @param persistent - Select the in-memory REPL bootstrap instead of the one-shot evaluator.
  * @returns Arguments following the resolved Node executable.
  */
-export declare function bootstrapArgs(fs: Pick<FileSystem, 'processPathFromHostPath'>, config: LaunchConfig, maxMessageBytes: number): string[];
+export declare function bootstrapArgs(fs: Pick<FileSystem, 'processPathFromHostPath'>, config: LaunchConfig, maxMessageBytes: number, persistent?: boolean): string[];
 //# sourceMappingURL=launch.d.ts.map

package/lib/types/output-ledger.d.ts

@@ -3,9 +3,10 @@ import type { PtcJsonValue, PtcRunFailure, PtcRunResult } from '@deepseek-ai/dsh
 /** One run's combined outer-output ledger; binding values never enter it. */
 export declare class OutputLedger {
     private readonly maxBytes;
+    private readonly overflowMessage?;
     private bytes;
     private entries;
-    constructor(maxBytes: number);
+    constructor(maxBytes: number, overflowMessage?: string | undefined);
     /** Admit one exact log entry, or report that the hard cap was crossed. */
     admit(text: string, sink: string[]): boolean;
     /** Finalize a successful absent-or-JSON completion against the combined cap. */

package/lib/types/output-stream.d.ts

@@ -1,5 +1,6 @@
 /** Bounded drainage for raw process output after managed execution ends. */
 import type { Readable } from 'node:stream';
+import type { SubprocessHandle } from '@deepseek-ai/dsh-subprocess';
 /**
  * Wait for queued bytes without letting an inherited descriptor retain a run forever.
  * @param stream - Caller-owned raw process output, when provided.
@@ -7,4 +8,11 @@ import type { Readable } from 'node:stream';
  * @returns Whether the complete stream ended without a transport error.
  */
 export declare function drainOutput(stream: Readable | undefined, graceMs: number): Promise<boolean>;
+/**
+ * Terminate a managed process and drain its pipes, including failures before output listeners attach.
+ * @param handle - Process and streams owned by the runtime.
+ * @param graceMs - Maximum pipe-drain wait after managed exit.
+ * @returns Whether both output streams ended cleanly.
+ */
+export declare function terminateProcess(handle: SubprocessHandle, graceMs: number): Promise<boolean>;
 //# sourceMappingURL=output-stream.d.ts.map

package/lib/types/persistent-process-entry.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=persistent-process-entry.d.ts.map

package/lib/types/persistent-process.d.ts

@@ -0,0 +1,18 @@
+import { type Duplex } from 'node:stream';
+import type { PatchableStream } from './bootstrap.ts';
+/** Process state owned by the REPL child; tests supply instance-local streams and environment. */
+export interface PersistentProcess {
+    env: NodeJS.ProcessEnv;
+    stdout: PatchableStream;
+    stderr: PatchableStream;
+    chdir(directory: string): void;
+}
+/**
+ * Serve sequential evaluations until the owning host closes the control channel.
+ * @param stream - Inherited private control endpoint.
+ * @param maxMessageBytes - Maximum control frame and queued output bytes.
+ * @param processState - Child environment, output and directory control, bound only in the REPL context.
+ * @returns After the channel closes and the REPL releases its streams.
+ */
+export declare function runPersistentMain(stream: Duplex, maxMessageBytes: number, processState: PersistentProcess): Promise<void>;
+//# sourceMappingURL=persistent-process.d.ts.map

package/lib/types/persistent.d.ts

@@ -0,0 +1,44 @@
+import { Context } from '@deepseek-ai/cordis';
+import type { PtcRunRequest, PtcRunSpec, PtcRunResult } from '@deepseek-ai/dsh-ptc-runtime';
+import type { PolicyProcesses } from './policy-processes.ts';
+import type { ResolvedConfig } from './config.ts';
+/** Sandboxed, best-effort retained state; restart, disposal, and interrupted execution clear it. */
+export declare class InMemoryExecution {
+    private readonly ctx;
+    private readonly config;
+    private readonly processes;
+    /**
+     * Model-facing rules for retained variables, authority, output, and recovery.
+     * @returns Usage guidance appended to the run_code schema.
+     */
+    get executionInstructions(): string;
+    private readonly owners;
+    private readonly kernels;
+    private disposed;
+    /**
+     * Own retained execution resources under the existing Node provider.
+     * @param ctx - Provider lifecycle and execution services.
+     * @param config - Validated limits and selected executable.
+     * @param processes - Provider-owned policy invalidation and cleanup.
+     */
+    constructor(ctx: Context, config: ResolvedConfig, processes: PolicyProcesses);
+    /**
+     * Resolve the file policy, directory and deadline for a retained REPL.
+     * @param request - Program, bindings, owner, directory and elapsed budget.
+     * @returns Resolved inputs with the selected file policy.
+     */
+    resolve(request: PtcRunRequest): PtcRunSpec;
+    /**
+     * Evaluate statements using this owner's process, or a temporary process without an owner.
+     * @param spec - Resolved request; concurrent calls for one owner are rejected.
+     * @returns Logs, a final JSON expression, or a structured execution failure.
+     */
+    run(spec: PtcRunSpec): Promise<PtcRunResult>;
+    /**
+     * Release retained state and await its process cleanup.
+     * @param owner - Exact object supplied to run.
+     * @returns Completion after the owned process and output streams stop.
+     */
+    release(owner: object): Promise<void>;
+}
+//# sourceMappingURL=persistent.d.ts.map

package/lib/types/policy-processes.d.ts

@@ -0,0 +1,30 @@
+/** Node PTC process invalidation after a committed Session file-policy change. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { SessionId } from '@deepseek-ai/dsh-session';
+import type { SandboxExecutionPolicy } from '@deepseek-ai/dsh-sandbox';
+/** Owns asynchronous process cleanup without delaying permission setters. */
+export declare class PolicyProcesses {
+    private readonly ctx;
+    private readonly processes;
+    /**
+     * Begin cleanup on policy changes, even when no subsequent program runs.
+     * @param ctx - Node provider lifecycle and Session services.
+     */
+    constructor(ctx: Context);
+    /**
+     * Track an admitted call or retained process until its owner confirms cleanup.
+     * @param policy - Resolved process policy, including an optional Session identity.
+     * @param release - Idempotent cancellation and awaited cleanup.
+     * @returns Removal after successful process cleanup.
+     */
+    register(policy: SandboxExecutionPolicy, release: () => Promise<void>): () => void;
+    /**
+     * Wait for invalidated processes before admitting another program.
+     * @param sessionId - Session carried by the resolved policy.
+     * @returns Completion after prior cleanup; a failure rejects and remains retryable.
+     */
+    wait(sessionId: SessionId | undefined): Promise<void>;
+    private release;
+    private settle;
+}
+//# sourceMappingURL=policy-processes.d.ts.map

package/locale/en.json

@@ -0,0 +1,5 @@
+{
+  "meta": {
+    "title": "ptc-runtime-node"
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Node PTC 运行时",
+    "description": "在沙箱中的 Node 进程里执行用于调用工具的代码。"
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-ptc-runtime-node",
-  "description": "Sandboxed Node process implementation of the DeepSeek Harness PTC execution capability",
-  "version": "0.2.1-alpha.2",
+  "description": "Node PTC execution with per-call sandboxed processes or in-memory REPL state",
+  "version": "0.2.1-alpha.4",
   "publishConfig": {
     "access": "public"
   },
@@ -22,40 +22,43 @@
     "./process": {
       "types": "./lib/types/process-entry.d.ts",
       "default": "./lib/process.js"
-    }
+    },
+    "./locale/*.json": "./locale/*.json"
   },
   "files": [
+    "locale/*.json",
     "lib/index.js",
     "lib/process.js",
+    "lib/persistent-process.js",
     "lib/types/**/*.d.ts"
   ],
   "license": "MIT",
   "peerDependencies": {
-    "@deepseek-ai/cordis": "~4.0.5-alpha.1",
-    "@deepseek-ai/dsh-ptc-runtime": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-session": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-timeout": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-fs": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-subprocess": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-sandbox": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-sandbox-policy": "0.2.1-alpha.2"
+    "@deepseek-ai/cordis": "~4.0.5-alpha.2",
+    "@deepseek-ai/dsh-ptc-runtime": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-session": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-timeout": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-fs": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-subprocess": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-sandbox": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-sandbox-policy": "0.2.1-alpha.4"
   },
   "dependencies": {
-    "@deepseek-ai/dsh-util-values": "0.2.1-alpha.2",
-    "@deepseek-ai/schemastery": "~3.18.5-alpha.1"
+    "@deepseek-ai/dsh-util-values": "0.2.1-alpha.4",
+    "@deepseek-ai/schemastery": "~3.18.5-alpha.2"
   },
   "devDependencies": {
-    "@deepseek-ai/cordis": "~4.0.5-alpha.1",
-    "@deepseek-ai/dsh-ptc-runtime": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-session": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-timeout": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-fs": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-subprocess": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-sandbox": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-sandbox-policy": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-fs-local": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-subprocess-local": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-session-projection": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-sandbox-local": "0.2.1-alpha.2"
+    "@deepseek-ai/cordis": "~4.0.5-alpha.2",
+    "@deepseek-ai/dsh-ptc-runtime": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-session": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-timeout": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-fs": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-subprocess": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-sandbox": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-sandbox-policy": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-fs-local": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-subprocess-local": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-session-projection": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-sandbox-local": "0.2.1-alpha.4"
   }
 }