super-dsh 0.1.0 → 0.1.2

package/agent-codex/dist/models.js

@@ -0,0 +1,152 @@
+/**
+ * Codex model catalog for the Dash model selector (AW-E Task 5).
+ *
+ * Reads the adapter's nested codex home the native way (spec S7: the native
+ * app self-populates its config; we read, never write):
+ * - `config.toml` top-level keys `model`, `model_reasoning_effort`,
+ *   `model_provider`, `model_catalog_json` (minimal line parser — the full
+ *   TOML grammar is deliberately not implemented; unknown lines are skipped);
+ * - `model_catalog_json` (relative to the codex home) → per-model identity
+ *   fields (slug / display_name / default_reasoning_level / context_window).
+ *
+ * The frozen multi-agent-ctx models.ts used the app-server `model/list` —
+ * that surface does not exist on the SDK line, so the TOML+catalog pair is
+ * the only catalog source. Fail-soft everywhere: any missing/unparsable piece
+ * degrades toward a single `codex-default` placeholder, never a throw.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolveCodexHome, useCodexHome } from "./codex-store.js";
+/** Minimal top-level TOML scan: `key = value` pairs + `[section]` headers. */
+function parseTopLevelToml(text) {
+    const values = {};
+    const sections = new Map();
+    let current = null;
+    let currentName = "";
+    for (const rawLine of text.split("\n")) {
+        const lineText = rawLine.trim();
+        if (lineText === "" || lineText.startsWith("#"))
+            continue;
+        const header = /^\[([^\]]+)\]$/.exec(lineText);
+        if (header !== null) {
+            currentName = header[1].trim();
+            current = {};
+            sections.set(currentName, current);
+            continue;
+        }
+        const eq = lineText.indexOf("=");
+        if (eq <= 0)
+            continue; // broken line — tolerated
+        const key = lineText.slice(0, eq).trim();
+        let value = lineText.slice(eq + 1).trim();
+        if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
+            value = value.slice(1, -1);
+        }
+        else if (value.startsWith("'") && value.endsWith("'") && value.length >= 2) {
+            value = value.slice(1, -1);
+        }
+        else {
+            // strip trailing comment on bare values; keep numbers/bools as strings
+            const hash = value.indexOf(" #");
+            if (hash >= 0)
+                value = value.slice(0, hash).trim();
+        }
+        if (current !== null && currentName !== "")
+            current[key] = value;
+        else
+            values[key] = value;
+    }
+    return { values, sections };
+}
+/** The fail-soft placeholder model id (never sent to the real codex binary). */
+export const CODEX_DEFAULT_MODEL_PLACEHOLDER = "codex-default";
+/** The fail-soft placeholder: one entry, no claims about the runtime. */
+function placeholder(defaultModel = CODEX_DEFAULT_MODEL_PLACEHOLDER) {
+    return { defaultModel, models: [{ id: defaultModel, label: "Codex default" }] };
+}
+/** Read the model catalog out of the codex home (fail-soft, never throws). */
+export function readCodexModelCatalog(codexHome) {
+    let home;
+    try {
+        home = codexHome !== undefined ? useCodexHome(codexHome) : resolveCodexHome();
+    }
+    catch {
+        return placeholder();
+    }
+    let configValues = {};
+    let providerName;
+    const configPath = join(home, "config.toml");
+    if (existsSync(configPath)) {
+        try {
+            const parsed = parseTopLevelToml(readFileSync(configPath, "utf8"));
+            configValues = parsed.values;
+            const providerId = configValues["model_provider"];
+            if (providerId !== undefined) {
+                const section = parsed.sections.get(`model_providers.${providerId}`);
+                if (section !== undefined && typeof section["name"] === "string" && section["name"] !== "") {
+                    providerName = section["name"];
+                }
+            }
+        }
+        catch {
+            return placeholder();
+        }
+    }
+    const configModel = configValues["model"];
+    const catalogRel = configValues["model_catalog_json"];
+    const entries = [];
+    if (catalogRel !== undefined && catalogRel !== "") {
+        const catalogPath = join(home, catalogRel);
+        if (existsSync(catalogPath)) {
+            try {
+                const parsed = JSON.parse(readFileSync(catalogPath, "utf8"));
+                const models = parsed?.models;
+                if (Array.isArray(models)) {
+                    for (const raw of models) {
+                        if (raw === null || typeof raw !== "object")
+                            continue;
+                        const m = raw;
+                        const slug = m["slug"];
+                        if (typeof slug !== "string" || slug === "")
+                            continue;
+                        const label = typeof m["display_name"] === "string" && m["display_name"] !== "" ? m["display_name"] : slug;
+                        const entry = {
+                            id: slug,
+                            label,
+                            ...(typeof m["default_reasoning_level"] === "string" && m["default_reasoning_level"] !== ""
+                                ? { reasoningEffort: m["default_reasoning_level"] }
+                                : {}),
+                            ...(typeof m["context_window"] === "number" && Number.isSafeInteger(m["context_window"])
+                                ? { contextWindow: m["context_window"] }
+                                : {}),
+                        };
+                        entries.push(entry);
+                    }
+                }
+            }
+            catch {
+                // unparsable catalog — fall through to the config-model entry
+            }
+        }
+    }
+    if (entries.length === 0) {
+        if (configModel === undefined || configModel === "")
+            return placeholder();
+        return {
+            defaultModel: configModel,
+            ...(providerName === undefined ? {} : { provider: providerName }),
+            models: [{ id: configModel, label: configModel }],
+        };
+    }
+    // The configured model is what sessions actually run, so it must be
+    // selectable even when the provider's own catalog file does not list it
+    // (cc-switch ships a fixed list; `config.toml` may name a newer entry).
+    const models = configModel !== undefined && configModel !== "" && !entries.some((entry) => entry.id === configModel)
+        ? [{ id: configModel, label: configModel }, ...entries]
+        : entries;
+    return {
+        defaultModel: configModel !== undefined && configModel !== "" ? configModel : entries[0].id,
+        ...(providerName === undefined ? {} : { provider: providerName }),
+        models,
+    };
+}

package/agent-codex/dist/permission.js

@@ -0,0 +1,71 @@
+/** The approval policies Codex actually implements (unknown values are ignored). */
+const APPROVAL_POLICIES = ["never", "on-request", "on-failure", "untrusted"];
+/** The Dash preset table (mirrors the base bundle's permission plugin config). */
+const PRESETS = {
+    "danger-full-access": { sandbox: "danger-full-access", approval: "never", codexPolicy: "never" },
+    "workspace-write": { sandbox: "workspace-write", approval: "ask", codexPolicy: "on-request" },
+    "read-only": { sandbox: "read-only", approval: "ask", codexPolicy: "never" },
+};
+/** Narrow an untrusted value to a known preset name. */
+export function isPresetName(raw) {
+    return typeof raw === "string" && Object.hasOwn(PRESETS, raw);
+}
+/**
+ * `CODEX_APPROVAL_MODE` when it names an approval policy Codex implements,
+ * else undefined. An invalid value is IGNORED (the preset mapping applies).
+ */
+export function envApprovalMode() {
+    const raw = process.env.CODEX_APPROVAL_MODE;
+    return raw !== undefined && APPROVAL_POLICIES.includes(raw) ? raw : undefined;
+}
+/**
+ * Map a preset onto Codex's `--approval-mode` value; no preset → never.
+ * A value that is ALREADY a codex approval policy (the env override rides
+ * through the same folded call) passes through untouched; unknown preset
+ * names degrade to never.
+ */
+export function codexApprovalMode(preset) {
+    if (preset !== undefined && APPROVAL_POLICIES.includes(preset))
+        return preset;
+    return isPresetName(preset) ? PRESETS[preset].codexPolicy : "never";
+}
+/**
+ * The default preset for FUTURE sessions, as the permission service
+ * resolves it (settings-backed; the profile patch pins the base default).
+ * Undefined when the service is absent or its getter fails — callers fall
+ * back to the codex default policy.
+ */
+export function defaultPermissionPreset(ctx) {
+    const service = ctx.get("permissionPresets");
+    if (service === undefined)
+        return undefined;
+    try {
+        const preset = service.defaultPreset;
+        return isPresetName(preset) ? preset : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The session's effective preset: the last `permission/preset` event. */
+export function presetFromEvents(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event.type === "permission/preset" && isPresetName(event.data?.preset))
+            return event.data.preset;
+    }
+    return undefined;
+}
+/**
+ * The three Dash events `pinInitialPermission` stamps for a fresh session,
+ * in its append order (preset, sandbox, approval). Cold replay prepends
+ * them so the UI shows the session's permission after wrapper restarts.
+ */
+export function permissionEventsFor(preset, time) {
+    const spec = PRESETS[preset];
+    return [
+        { type: "permission/preset", time, data: { preset } },
+        { type: "sandbox/mode", time, data: { mode: spec.sandbox } },
+        { type: "approval/policy", time, data: { policy: spec.approval } },
+    ];
+}

package/agent-codex/dist/session-map.js

@@ -0,0 +1,170 @@
+/**
+ * DSH-session ↔ Codex-thread identity map (the "mapping only" model,
+ * 2026-09-16).
+ *
+ * The DSH session id is the authority: it is supplied by the harness at
+ * create/resume and is what the API layer routes on. Codex's thread id only
+ * materializes after the first turn, so the pairing is persisted here, in an
+ * adapter-owned JSON file in the world's DSH home root (NOT inside the codex
+ * app home — the app home is the CLI's native `~/.codex` since the 2026-09-17
+ * home ruling; DSH bookkeeping never lives in the runtime's native tree):
+ *
+ *   `<worldHome>/dsh-sessions.json`   (`<DSH home>/agents/codex/dsh-sessions.json`)
+ *
+ * Shape: `{ "<dshSessionId>": { threadId, cwd, createdAt, preset } }` —
+ * `threadId` is `null` until the Codex thread starts. Writes are atomic
+ * (temp file + rename); reads are fail-soft (malformed JSON reads as empty)
+ * and never throw, so a corrupt map degrades to "unknown session" rather
+ * than breaking every operation.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { assertNotProdHome } from "./codex-store.js";
+/** An `Error` carrying a stable {@link CodexResumeErrorCode}. */
+export class CodexResumeError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "CodexResumeError";
+        this.code = code;
+    }
+}
+/** The map file's path inside the adapter's app home. */
+/**
+ * The adapter's DSH-side state dir — the world's DSH home root
+ * (`<dshHome>/agents/codex`), never the codex app home. Precedence: explicit
+ * world home (boot-provided `dshHomePath`), then `$DSH_HOME` (a hub home, so
+ * the world layout nests `agents/codex`), then the line's historical test-home
+ * default. Prod-guarded.
+ */
+export function resolveCodexStateDir(home) {
+    if (home !== undefined) {
+        const dir = resolve(home);
+        assertNotProdHome(dir, "codex state dir");
+        return dir;
+    }
+    const fallbackHome = resolve(process.env.DSH_HOME ?? join(process.cwd(), ".tests", "aw"));
+    const dir = join(fallbackHome, "agents", "codex");
+    assertNotProdHome(dir, "codex state dir");
+    return dir;
+}
+/** The map file's path at the world DSH-home root. */
+export function sessionMapPath(home) {
+    return join(resolveCodexStateDir(home), "dsh-sessions.json");
+}
+/** Read the map. Fail-soft: a missing or malformed file reads as `{}`. */
+export function readSessionMap(home) {
+    let raw;
+    try {
+        raw = readFileSync(sessionMapPath(home), "utf8");
+    }
+    catch {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return {};
+    const out = {};
+    for (const [id, value] of Object.entries(parsed)) {
+        const record = coerceRecord(value);
+        if (record !== undefined)
+            out[id] = record;
+    }
+    return out;
+}
+/** Validate one entry; malformed entries are dropped (fail-soft). */
+function coerceRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const raw = value;
+    const cwd = raw["cwd"];
+    const createdAt = raw["createdAt"];
+    if (typeof cwd !== "string" || cwd === "")
+        return undefined;
+    const threadId = raw["threadId"];
+    const preset = raw["preset"];
+    return {
+        threadId: typeof threadId === "string" && threadId !== "" ? threadId : null,
+        cwd,
+        createdAt: typeof createdAt === "number" && Number.isFinite(createdAt) ? createdAt : 0,
+        preset: typeof preset === "string" && preset !== "" ? preset : null,
+        ...(typeof raw["resumable"] === "boolean" ? { resumable: raw["resumable"] } : {}),
+    };
+}
+/** One session's record, or `undefined` when the id is unknown. */
+export function sessionRecord(home, dshSessionId) {
+    return readSessionMap(home)[dshSessionId];
+}
+/**
+ * Insert or merge one session's record and persist the map atomically
+ * (temp file + rename, same directory). Merge semantics: an omitted `patch`
+ * field keeps the stored value; `threadId: null` explicitly records "not yet
+ * materialized". Throws only when the write itself fails — the caller owns
+ * that decision (create treats an unwritable map as fatal; the observation
+ * path logs and continues).
+ */
+export function upsertSession(home, dshSessionId, patch) {
+    const path = sessionMapPath(home);
+    const map = readSessionMap(home);
+    const previous = map[dshSessionId];
+    const next = {
+        threadId: patch.threadId !== undefined ? patch.threadId : previous?.threadId ?? null,
+        cwd: patch.cwd !== undefined ? patch.cwd : previous?.cwd ?? "",
+        createdAt: patch.createdAt !== undefined ? patch.createdAt : previous?.createdAt ?? Date.now(),
+        preset: patch.preset !== undefined ? patch.preset : previous?.preset ?? null,
+        // Sticky once false (an omitted patch keeps the stored refusal).
+        ...(patch.resumable !== undefined
+            ? { resumable: patch.resumable }
+            : previous?.resumable === false
+                ? { resumable: false }
+                : {}),
+    };
+    map[dshSessionId] = next;
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
+    const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(temp, `${JSON.stringify(map, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    try {
+        renameSync(temp, path);
+    }
+    catch (error) {
+        try {
+            rmSync(temp, { force: true });
+        }
+        catch {
+            // The rename failure is primary.
+        }
+        throw error;
+    }
+    return next;
+}
+/** Drop one session's record (idempotent; failure to persist rethrows). */
+export function forgetSession(home, dshSessionId) {
+    const path = sessionMapPath(home);
+    if (!existsSync(path))
+        return;
+    const map = readSessionMap(home);
+    if (map[dshSessionId] === undefined)
+        return;
+    delete map[dshSessionId];
+    const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(temp, `${JSON.stringify(map, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    try {
+        renameSync(temp, path);
+    }
+    catch (error) {
+        try {
+            rmSync(temp, { force: true });
+        }
+        catch {
+            // The rename failure is primary.
+        }
+        throw error;
+    }
+}

package/agent-codex/dist/spike.js

@@ -0,0 +1,46 @@
+/**
+ * AW-E Task 1 spike (P0 gate): prove `@openai/codex-sdk@0.154.0` drives a real
+ * turn against the local cc-switch provider (glm-5.2) under an ISOLATED
+ * CODEX_HOME, and capture the raw ThreadEvent chain for the Task 2 projection
+ * fixtures. The SDK spawns its own exact-pinned codex binary — the 0.153.4
+ * CLI on PATH is never consulted (version-mix safety, 2026-09-10 fact).
+ */
+import { Codex } from "@openai/codex-sdk";
+function lastOfType(events, type) {
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        const evt = events[i];
+        if (evt.type === type)
+            return evt;
+    }
+    return undefined;
+}
+/** Run one real streamed turn and collect the full event chain. */
+export async function runSpike(opts) {
+    const codex = new Codex({
+        // env REPLACES process.env (SDK contract) — carry it forward + redirect home.
+        env: { ...process.env, CODEX_HOME: opts.codexHome },
+    });
+    const thread = codex.startThread({
+        workingDirectory: opts.cwd,
+        skipGitRepoCheck: true,
+        approvalPolicy: "never",
+        sandboxMode: "read-only",
+    });
+    const events = [];
+    const streamed = await thread.runStreamed(opts.prompt ?? "Reply with exactly: ok");
+    for await (const evt of streamed.events) {
+        events.push(evt);
+        if (evt.type === "turn.failed") {
+            const error = evt.error;
+            throw new Error(`spike turn failed: ${error?.message ?? "unknown"}`);
+        }
+    }
+    const completed = lastOfType(events, "turn.completed");
+    const message = lastOfType(events, "item.completed");
+    return {
+        threadId: thread.id ?? "",
+        finalResponse: message?.item?.text ?? "",
+        usage: completed?.usage ?? null,
+        events,
+    };
+}

package/agent-codex/dist/world-plugin.js

@@ -0,0 +1,96 @@
+/**
+ * aw.agent-adapter-codex — the Codex adapter's WORLD plugin (spec S2):
+ * activation IS roster membership.
+ *
+ * AW-B URL scheme (DL1–DL5), mirroring `@pgmi-builds/agent-adapter-omp/world`
+ * so the hub sees both foreign runtimes through one shape: the world is spawned
+ * as a sibling ROOT context with NO listener (`worldMountPatches`) and mounts
+ * itself under `/codex` through the hub —
+ *
+ *   1. ctx0 publishes the host mount (real webServer instance) before spawn;
+ *   2. the world's entry row provides the virtual `webServer` in the world
+ *      root, translating every route its plugins declare into `/codex+path`;
+ *   3. the hub's carrier answers `/codex/api` + `/codex/api/remote.mux` in
+ *      ctx0's auth domain and dispatches into this world's gateway instance.
+ */
+import { mkdirSync } from 'node:fs';
+import { resolveDshHome } from '@deepseek-ai/dsh-home-paths';
+import { join } from 'node:path';
+import { spawnWorld, registerAgent, setReady, registerForeignTarget, registerHostMount, mountWorld, worldMountPatches, provisionWorldProfile, } from '../../agent-hub/dist/index.js';
+export const name = 'aw.agent-adapter-codex';
+/** Runtime key — also the mount label. */
+const KEY = 'codex';
+const ANCHOR = process.env.SUPERD_DSH_ANCHOR
+    ?? '/home/u1/.local/lib/node_modules/@deepseek-ai/dsh/package.json';
+export function apply(ctx) {
+    registerAgent({ key: KEY, label: 'Codex', ready: false });
+    // Harness resolver (env → ~/.dsh): a consumer install has no DSH_HOME and
+    // no cwd contract — deriving the world root from cwd spawns worlds into a
+    // garbage tree or throws inside apply() and kills the whole host boot.
+    const root = resolveDshHome();
+    // S7 nested home: every runtime owns one root under `agents/<label>`; the
+    // world's DSH data lives INSIDE it (sessions / settings / workspaces) and the
+    // foreign app's own store (`.codex`) sits in the same root.
+    const worldHome = join(root, 'agents', KEY);
+    mkdirSync(join(worldHome, 'profiles'), { recursive: true });
+    // Publish story: a foreign install has no line bootstrap, so the nested
+    // profile + @pgmi-builds links are provisioned HERE (idempotent; dev lines
+    // keep parity — smoke.mjs wrote the same layout, and AW_BARE_BASE still
+    // overrides the resolved base).
+    const bareBase = provisionWorldProfile({
+        key: KEY,
+        adapterPkg: '@pgmi-builds/agent-adapter-codex',
+        worldHome,
+    });
+    const world = (async () => {
+        // Wait for ctx0's listening stack: the mount needs the real webServer and
+        // the browser-trust fence from the live connection service.
+        const host = await new Promise((resolve) => {
+            ctx.inject(['webServer', 'connection'], (hostCtx) => { resolve(hostCtx); });
+        });
+        const real = host['webServer'];
+        const connection = host['connection'];
+        const dropHostMount = registerHostMount({
+            key: KEY,
+            labelPath: `/${KEY}`,
+            real,
+            // ctx0's index gate, applied by the mount to this world's pages and assets:
+            // the world is reached in-ctx and owns no listener, so ctx0 decides auth.
+            authorize: (req, res) => connection.authorizeIndex(req, res),
+        });
+        const ctxW = await spawnWorld({
+            appName: `aw-${KEY}`,
+            profileName: 'web',
+            installAnchor: ANCHOR,
+            home: worldHome,
+            dataHome: worldHome,
+            // Adapter-local bundle names resolve from the profile's own
+            // node_modules (heal owns @deepseek-ai there; @pgmi-builds links are
+            // provisioned by provisionWorldProfile above, or by the line bootstrap
+            // when the adapter package was not resolvable — env wins over both).
+            bareModuleBaseUrl: process.env.AW_BARE_BASE ?? bareBase ?? undefined,
+            extraPatches: worldMountPatches(KEY),
+        });
+        const gateway = ctxW.get('typertGateway');
+        registerForeignTarget({ key: KEY, gateway });
+        const mounted = mountWorld({
+            real,
+            label: KEY,
+            gateway,
+            requestRejection: (request) => connection
+                .requestRejection(request),
+        });
+        setReady(KEY, true);
+        ctx.effect?.(() => () => {
+            mounted.dispose();
+            dropHostMount();
+        }, `aw.agent-adapter-${KEY}: mount`);
+        return ctxW;
+    })().catch((cause) => {
+        // A failed world degrades to a not-ready roster row; a rejected provided
+        // promise would fail the entire host boot (loader entry apply).
+        console.error(`[super-dsh] ${KEY} world failed:`, cause);
+        return null;
+    });
+    ctx.provide(`aw.world.${KEY}`, world);
+}

package/agent-codex/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@pgmi-builds/agent-adapter-codex",
+  "version": "0.1.0",
+  "description": "Codex provider for DeepSeek Harness (dsh) — an AgentFactory that embeds Codex CLI via the @openai/codex-sdk and bridges Codex's session surface into Dash Agent/Session contracts (Agent Worlds AW-E, SDK line).",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./world": "./dist/world-plugin.js"
+  },
+  "files": [
+    "dist",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "node --test test/*.test.mjs"
+  },
+  "dependencies": {
+    "@openai/codex": "0.154.0",
+    "@openai/codex-sdk": "0.154.0",
+    "@pgmi-builds/agent-hub": "file:../agent-hub",
+    "zod": "3.25.76"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-agent-presets": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-llm": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-scope": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-session": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-session-persistence": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-typert-protocol": "0.1.5-rc.2"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-agent": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-agent-presets": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-llm": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-scope": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session-persistence": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-typert-protocol": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "typescript": "^5.6.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "main": "dist/index.js",
+  "engines": {
+    "node": ">=22.18"
+  }
+}