@yadsh/dsh-sleev 0.0.1

package/lib/index.js

@@ -0,0 +1,241 @@
+import { Service } from "@deepseek-ai/cordis";
+import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
+import z from "@deepseek-ai/schemastery";
+import { isAgentLoopRequest } from "@deepseek-ai/dsh-llm";
+import { randomUUID } from "node:crypto";
+//#region src/shared/config.ts
+/** Cordis loader schema. Semantic validation remains in {@link resolveConfig}. */
+const ConfigSchema = z.object({
+	routes: z.array(z.string()).default([]),
+	routePrefixes: z.array(z.string()).default(["sleev-"]),
+	maxRecentCalls: z.number().step(1).min(1).default(100),
+	logLevel: z.union([
+		"off",
+		"info",
+		"debug"
+	]).default("info")
+});
+function uniqueNonEmpty(values, field) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const value of values) {
+		const normalized = value.trim();
+		if (normalized.length === 0) throw new Error(`dsh-sleev: ${field} cannot contain an empty value`);
+		if (seen.has(normalized)) continue;
+		seen.add(normalized);
+		result.push(normalized);
+	}
+	return result;
+}
+/** Apply runtime defaults and reject ambiguous route matchers. */
+function resolveConfig(config = {}) {
+	const maxRecentCalls = config.maxRecentCalls ?? 100;
+	if (!Number.isSafeInteger(maxRecentCalls) || maxRecentCalls < 1) throw new Error("dsh-sleev: maxRecentCalls must be a positive safe integer");
+	return Object.freeze({
+		routes: Object.freeze(uniqueNonEmpty(config.routes ?? [], "routes")),
+		routePrefixes: Object.freeze(uniqueNonEmpty(config.routePrefixes ?? ["sleev-"], "routePrefixes")),
+		maxRecentCalls,
+		logLevel: config.logLevel ?? "info"
+	});
+}
+/** Whether a DSH route is explicitly declared as externally optimized. */
+function matchesOptimizedRoute(provider, config) {
+	return config.routes.includes(provider) || config.routePrefixes.some((prefix) => provider.startsWith(prefix));
+}
+//#endregion
+//#region src/shared/settings.ts
+/** Stable raw namespace shared by the Host registration and browser card. */
+const SLEEV_SETTINGS_NAMESPACE_ID = "sleev";
+//#endregion
+//#region src/host/request-classifier.ts
+/** Classify main loop and known auxiliary calls without inspecting prompts. */
+function classifyRequest(options) {
+	if (options.purpose === "compaction") return "compaction";
+	if (options.purpose === "session-title") return "session-title";
+	if (isAgentLoopRequest(options)) return "agent";
+	if (options.purpose === void 0) return "one-shot";
+	return "unknown";
+}
+//#endregion
+//#region src/host/stream-observer.ts
+function errorCode(error) {
+	const code = error?.code;
+	return typeof code === "string" && code.length > 0 ? code : void 0;
+}
+/**
+* Observe usage and terminal state while yielding every downstream chunk once,
+* unchanged and without buffering. Early consumer return is recorded as abort.
+*/
+async function* observeStream(downstream, observation) {
+	let terminal = false;
+	try {
+		for await (const chunk of downstream) {
+			if (chunk.type === "usage") observation.observeUsage(chunk.usage);
+			if (chunk.type === "finish") {
+				terminal = true;
+				if (chunk.reason.kind === "aborted") observation.finish({ kind: "aborted" });
+				else if (chunk.reason.kind === "error") observation.finish({
+					kind: "error",
+					...chunk.reason.failure.code.length === 0 ? {} : { code: chunk.reason.failure.code }
+				});
+				else observation.finish({ kind: "success" });
+			}
+			yield chunk;
+		}
+		if (!terminal) {
+			terminal = true;
+			observation.finish({
+				kind: "error",
+				code: "STREAM_INCOMPLETE"
+			});
+		}
+	} catch (error) {
+		if (!terminal) {
+			terminal = true;
+			const code = errorCode(error);
+			observation.finish({
+				kind: "error",
+				...code === void 0 ? {} : { code }
+			});
+		}
+		throw error;
+	} finally {
+		if (!terminal) observation.finish({ kind: "aborted" });
+	}
+}
+//#endregion
+//#region src/host/usage.ts
+/** Normalize optional cache buckets while preserving disjoint semantics. */
+function normalizeUsage(usage) {
+	return Object.freeze({
+		inputTokens: usage.inputTokens,
+		outputTokens: usage.outputTokens,
+		cacheReadTokens: usage.cacheReadTokens ?? 0,
+		cacheWriteTokens: usage.cacheWriteTokens ?? 0,
+		...usage.reasoningTokens === void 0 ? {} : { reasoningTokens: usage.reasoningTokens }
+	});
+}
+/** Compute effective provider input as uncached + cache reads + cache writes. */
+function deriveUsage(usage) {
+	return Object.freeze({ effectiveInputTokens: usage.inputTokens + usage.cacheReadTokens + usage.cacheWriteTokens });
+}
+//#endregion
+//#region src/host/telemetry-store.ts
+/** Bounded, process-local telemetry owner for the M1 observer. */
+var CallTelemetryStore = class {
+	logger;
+	completed = [];
+	now;
+	createId;
+	constructor(logger, config, options = {}) {
+		this.logger = logger;
+		this.readConfig = typeof config === "function" ? config : () => config;
+		this.now = options.now ?? Date.now;
+		this.createId = options.createId ?? randomUUID;
+	}
+	readConfig;
+	/** Begin one call and return an idempotent lifecycle sink. */
+	begin(options, kind) {
+		const startConfig = this.readConfig();
+		const callId = this.createId();
+		const startedAt = this.now();
+		let usage;
+		let finished = false;
+		if (startConfig.logLevel === "debug") this.logger.debug(`dsh-sleev: call-start ${JSON.stringify({
+			callId,
+			provider: options.provider,
+			model: options.model,
+			kind,
+			sessionId: options.sessionId
+		})}`);
+		return {
+			observeUsage: (value) => {
+				usage = normalizeUsage(value);
+			},
+			finish: (result) => {
+				if (finished) return;
+				finished = true;
+				const finishedAt = this.now();
+				const telemetry = Object.freeze({
+					schemaVersion: 1,
+					callId,
+					...options.sessionId === void 0 ? {} : { sessionId: String(options.sessionId) },
+					kind,
+					provider: options.provider,
+					model: options.model,
+					optimizer: "sleev",
+					startedAt,
+					finishedAt,
+					durationMs: Math.max(0, finishedAt - startedAt),
+					...usage === void 0 ? {} : {
+						providerUsage: usage,
+						derived: deriveUsage(usage)
+					},
+					result
+				});
+				this.completed.push(telemetry);
+				const finishConfig = this.reconfigure();
+				if (finishConfig.logLevel !== "off") {
+					const message = `dsh-sleev: call-end ${JSON.stringify(telemetry)}`;
+					if (finishConfig.logLevel === "debug") this.logger.debug(message);
+					else this.logger.info(message);
+				}
+			}
+		};
+	}
+	/** Return a detached newest-last snapshot for diagnostics and future UI. */
+	listRecent() {
+		return this.completed.slice();
+	}
+	/** Apply a changed retention bound immediately and return its config. */
+	reconfigure() {
+		const config = this.readConfig();
+		if (this.completed.length > config.maxRecentCalls) this.completed.splice(0, this.completed.length - config.maxRecentCalls);
+		return config;
+	}
+};
+//#endregion
+//#region src/index.ts
+const name = "dsh-sleev";
+/** User-editable settings section rendered by the browser client card. */
+const SLEEV_SETTINGS_NAMESPACE = settingsNamespace(SLEEV_SETTINGS_NAMESPACE_ID);
+/** Host-side observer service. Routing itself remains owned by llm-pi-ai. */
+var SleevIntegrationService = class extends Service {
+	static inject = ["llm"];
+	static Config = ConfigSchema;
+	telemetry;
+	constructor(ctx, input = {}) {
+		super(ctx, "sleev");
+		const resolvedEntry = resolveConfig(input);
+		const entry = {
+			routes: [...resolvedEntry.routes],
+			routePrefixes: [...resolvedEntry.routePrefixes],
+			maxRecentCalls: resolvedEntry.maxRecentCalls,
+			logLevel: resolvedEntry.logLevel
+		};
+		let configSource = () => entry;
+		this.telemetry = new CallTelemetryStore(ctx.logger, () => resolveConfig(configSource()));
+		installSettingsSection(ctx, SLEEV_SETTINGS_NAMESPACE, ConfigSchema, entry, {
+			setSource: (current) => {
+				configSource = current;
+			},
+			onChange: () => this.telemetry.reconfigure()
+		});
+		ctx.on("llm/stream", (options, next) => {
+			const config = resolveConfig(configSource());
+			if (!matchesOptimizedRoute(options.provider, config)) return next();
+			const handle = this.telemetry.begin(options, classifyRequest(options));
+			return observeStream(next(), handle);
+		}, { global: true });
+		if (resolvedEntry.logLevel !== "off") ctx.logger.info(`dsh-sleev: observer active ${JSON.stringify({
+			routes: resolvedEntry.routes,
+			routePrefixes: resolvedEntry.routePrefixes
+		})}`);
+	}
+	/** Bounded completed-call snapshot; no prompts, headers, or credentials. */
+	listRecentCalls() {
+		return this.telemetry.listRecent();
+	}
+};
+//#endregion
+export { CallTelemetryStore, ConfigSchema, SLEEV_SETTINGS_NAMESPACE, SleevIntegrationService, SleevIntegrationService as default, classifyRequest, deriveUsage, matchesOptimizedRoute, name, normalizeUsage, observeStream, resolveConfig };

package/lib/shared/telemetry.js

@@ -0,0 +1 @@
+export {};

package/lib/types/client/index.d.ts

@@ -0,0 +1,17 @@
+import type { ClientContext } from "@deepseek-ai/dsh-client-runtime/client";
+import type { InjectFace, PropsLocale, PropsRuntime } from "@deepseek-ai/dsh-client-ui-slots";
+import { type SleevSettingsCardFace } from "./settings-controller.js";
+export * from "./settings-controller.js";
+type SleevLocaleKey = "title" | "description" | "expand" | "collapse" | "unsaved" | "overridden" | "reset" | "routes" | "routesHint" | "routePrefixes" | "routePrefixesHint" | "maxRecentCalls" | "maxRecentCallsHint" | "logLevel" | "logLevelHint" | "logOff" | "logInfo" | "logDebug" | "invalidNumber" | "readOnly" | "saveFailed" | "discard" | "save" | "saving";
+declare module "@deepseek-ai/dsh-client-ui-slots" {
+    interface LocaleNamespaceMap {
+        "dsh-sleev": SleevLocaleKey;
+    }
+}
+type SleevSettingsCardProps = PropsRuntime<"settings.plugin.item"> & PropsLocale<"dsh-sleev"> & InjectFace<SleevSettingsCardFace>;
+/** Settings card contributed to the official Plugins → Plugin configuration tab. */
+export declare function SleevSettingsCard(props: SleevSettingsCardProps): import("react/jsx-runtime").JSX.Element | null;
+export declare const inject: string[];
+/** Register Sleev's localized settings card in the official keyed plugin slot. */
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/settings-controller.d.ts

@@ -0,0 +1,59 @@
+import { type SettingsScope, type SnapshotStore } from "@deepseek-ai/dsh-client-runtime/client";
+export type SleevLogLevel = "off" | "info" | "debug";
+/** Browser-visible shape of the Host `sleev` settings namespace. */
+export interface SleevSettings {
+    readonly routes?: string[];
+    readonly routePrefixes?: string[];
+    readonly maxRecentCalls?: number;
+    readonly logLevel?: SleevLogLevel;
+}
+export type SleevSettingsField = keyof SleevSettings;
+export interface SleevSettingsFieldState {
+    readonly text: string;
+    readonly overridden: boolean;
+    readonly invalid: boolean;
+}
+export interface SleevSettingsCardState {
+    readonly available: boolean;
+    readonly writable: boolean;
+    readonly dirty: boolean;
+    readonly invalid: boolean;
+    readonly saving: boolean;
+    readonly failed: boolean;
+    readonly routes: SleevSettingsFieldState;
+    readonly routePrefixes: SleevSettingsFieldState;
+    readonly maxRecentCalls: SleevSettingsFieldState;
+    readonly logLevel: SleevSettingsFieldState;
+}
+export interface SleevSettingsCardFace {
+    readonly hooks: {
+        readonly sleevSettings: SnapshotStore<SleevSettingsCardState>;
+    };
+    readonly edit: (field: SleevSettingsField, value: string) => void;
+    readonly save: () => void;
+    readonly discard: () => void;
+    readonly resetField: (field: SleevSettingsField) => void;
+}
+/** Staged form controller matching DSH's built-in plugin settings cards. */
+export declare class SleevSettingsController {
+    private readonly scope;
+    private readonly drafts;
+    private readonly store;
+    private readonly unsubscribe;
+    private saving;
+    private failed;
+    constructor(scope: SettingsScope<SleevSettings>);
+    inject(): SleevSettingsCardFace;
+    dispose(): void;
+    private base;
+    private effective;
+    private stored;
+    private format;
+    private parse;
+    private fieldState;
+    private plan;
+    private project;
+    private save;
+    private publish;
+}
+//# sourceMappingURL=settings-controller.d.ts.map

package/lib/types/host/optimizer/sleev/headers.d.ts

@@ -0,0 +1,29 @@
+/** Default loopback listener installed by the Sleev CLI. */
+export declare const DEFAULT_SLEEV_GATEWAY_URL = "http://127.0.0.1:17321/v1";
+/**
+ * Temporary compatibility choice for DSH's pi-ai transport.
+ *
+ * Sleev does not currently document a native DeepSeek Harness id. Keep this
+ * value visible and user-overridable rather than presenting it as guaranteed.
+ */
+export declare const EXPERIMENTAL_DSH_HARNESS_ID = "pi";
+/** Route a provider Sleev knows by its provider id. */
+export interface SleevKnownProviderTarget {
+    readonly kind: "provider";
+    readonly provider: string;
+    readonly harnessId: string;
+}
+/** Route an arbitrary OpenAI-compatible upstream URL through Sleev. */
+export interface SleevCustomProviderTarget {
+    readonly kind: "custom";
+    readonly baseUrl: string;
+    readonly harnessId: string;
+}
+/** Sleev routing target accepted by {@link buildSleevHeaders}. */
+export type SleevRouteTarget = SleevKnownProviderTarget | SleevCustomProviderTarget;
+/**
+ * Build only the public Sleev routing headers. Authorization remains owned by
+ * DSH credentials and llm-pi-ai, so this result can be logged or inspected.
+ */
+export declare function buildSleevHeaders(target: SleevRouteTarget): Readonly<Record<string, string>>;
+//# sourceMappingURL=headers.d.ts.map

package/lib/types/host/request-classifier.d.ts

@@ -0,0 +1,5 @@
+import { type GenerateOptions } from "@deepseek-ai/dsh-llm";
+import type { RequestKind } from "../shared/telemetry.js";
+/** Classify main loop and known auxiliary calls without inspecting prompts. */
+export declare function classifyRequest(options: GenerateOptions): RequestKind;
+//# sourceMappingURL=request-classifier.d.ts.map

package/lib/types/host/stream-observer.d.ts

@@ -0,0 +1,15 @@
+import type { StreamChunk } from "@deepseek-ai/dsh-llm";
+import type { CallResult } from "../shared/telemetry.js";
+/** Lifecycle callbacks used by the transparent stream wrapper. */
+export interface StreamObservation {
+    observeUsage(usage: Extract<StreamChunk, {
+        type: "usage";
+    }>["usage"]): void;
+    finish(result: CallResult): void;
+}
+/**
+ * Observe usage and terminal state while yielding every downstream chunk once,
+ * unchanged and without buffering. Early consumer return is recorded as abort.
+ */
+export declare function observeStream(downstream: AsyncIterable<StreamChunk>, observation: StreamObservation): AsyncIterable<StreamChunk>;
+//# sourceMappingURL=stream-observer.d.ts.map

package/lib/types/host/telemetry-store.d.ts

@@ -0,0 +1,34 @@
+import type { GenerateOptions, TokenUsage } from "@deepseek-ai/dsh-llm";
+import type { ResolvedConfig } from "../shared/config.js";
+import type { CallResult, OptimizerCallTelemetry, RequestKind } from "../shared/telemetry.js";
+/** Minimal logger face used by Cordis and isolated unit tests. */
+export interface TelemetryLogger {
+    debug(message: string): void;
+    info(message: string): void;
+}
+/** Mutable handle kept only for the duration of a streaming call. */
+export interface CallHandle {
+    observeUsage(usage: TokenUsage): void;
+    finish(result: CallResult): void;
+}
+interface StoreOptions {
+    readonly now?: () => number;
+    readonly createId?: () => string;
+}
+/** Bounded, process-local telemetry owner for the M1 observer. */
+export declare class CallTelemetryStore {
+    private readonly logger;
+    private readonly completed;
+    private readonly now;
+    private readonly createId;
+    constructor(logger: TelemetryLogger, config: ResolvedConfig | (() => ResolvedConfig), options?: StoreOptions);
+    private readonly readConfig;
+    /** Begin one call and return an idempotent lifecycle sink. */
+    begin(options: GenerateOptions, kind: RequestKind): CallHandle;
+    /** Return a detached newest-last snapshot for diagnostics and future UI. */
+    listRecent(): readonly OptimizerCallTelemetry[];
+    /** Apply a changed retention bound immediately and return its config. */
+    reconfigure(): ResolvedConfig;
+}
+export {};
+//# sourceMappingURL=telemetry-store.d.ts.map

package/lib/types/host/usage.d.ts

@@ -0,0 +1,7 @@
+import type { TokenUsage } from "@deepseek-ai/dsh-llm";
+import type { DerivedUsageTelemetry, ProviderUsageTelemetry } from "../shared/telemetry.js";
+/** Normalize optional cache buckets while preserving disjoint semantics. */
+export declare function normalizeUsage(usage: TokenUsage): ProviderUsageTelemetry;
+/** Compute effective provider input as uncached + cache reads + cache writes. */
+export declare function deriveUsage(usage: ProviderUsageTelemetry): DerivedUsageTelemetry;
+//# sourceMappingURL=usage.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,29 @@
+import { Context, Service } from "@deepseek-ai/cordis";
+import type { Config } from "./shared/config.js";
+import type { OptimizerCallTelemetry } from "./shared/telemetry.js";
+export declare const name = "dsh-sleev";
+/** User-editable settings section rendered by the browser client card. */
+export declare const SLEEV_SETTINGS_NAMESPACE: import("@deepseek-ai/dsh-settings").SettingsNamespace;
+declare module "@deepseek-ai/cordis" {
+    interface Context {
+        sleev: SleevIntegrationService;
+    }
+}
+/** Host-side observer service. Routing itself remains owned by llm-pi-ai. */
+export declare class SleevIntegrationService extends Service {
+    static inject: string[];
+    static Config: import("@deepseek-ai/schemastery").default<Config>;
+    private readonly telemetry;
+    constructor(ctx: Context, input?: Config);
+    /** Bounded completed-call snapshot; no prompts, headers, or credentials. */
+    listRecentCalls(): readonly OptimizerCallTelemetry[];
+}
+export { classifyRequest } from "./host/request-classifier.js";
+export { observeStream } from "./host/stream-observer.js";
+export { CallTelemetryStore } from "./host/telemetry-store.js";
+export { deriveUsage, normalizeUsage } from "./host/usage.js";
+export { ConfigSchema, matchesOptimizedRoute, resolveConfig, } from "./shared/config.js";
+export type { Config, ResolvedConfig } from "./shared/config.js";
+export type * from "./shared/telemetry.js";
+export default SleevIntegrationService;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/shared/config.d.ts

@@ -0,0 +1,26 @@
+import z from "@deepseek-ai/schemastery";
+/** Loader configuration for the host-side Sleev observer. */
+export interface Config {
+    /** Exact DSH provider route names known to pass through Sleev. */
+    readonly routes?: string[];
+    /** Provider-name prefixes known to pass through Sleev (default `sleev-`). */
+    readonly routePrefixes?: string[];
+    /** Maximum number of completed calls retained in process memory (default 100). */
+    readonly maxRecentCalls?: number;
+    /** Telemetry logging verbosity (default `info`). */
+    readonly logLevel?: "off" | "info" | "debug";
+}
+/** Fully materialized and validated observer configuration. */
+export interface ResolvedConfig {
+    readonly routes: readonly string[];
+    readonly routePrefixes: readonly string[];
+    readonly maxRecentCalls: number;
+    readonly logLevel: "off" | "info" | "debug";
+}
+/** Cordis loader schema. Semantic validation remains in {@link resolveConfig}. */
+export declare const ConfigSchema: z<Config>;
+/** Apply runtime defaults and reject ambiguous route matchers. */
+export declare function resolveConfig(config?: Config): ResolvedConfig;
+/** Whether a DSH route is explicitly declared as externally optimized. */
+export declare function matchesOptimizedRoute(provider: string, config: Pick<ResolvedConfig, "routes" | "routePrefixes">): boolean;
+//# sourceMappingURL=config.d.ts.map

package/lib/types/shared/settings.d.ts

@@ -0,0 +1,3 @@
+/** Stable raw namespace shared by the Host registration and browser card. */
+export declare const SLEEV_SETTINGS_NAMESPACE_ID = "sleev";
+//# sourceMappingURL=settings.d.ts.map

package/lib/types/shared/telemetry.d.ts

@@ -0,0 +1,40 @@
+/** Stable request classification used by host metrics and future clients. */
+export type RequestKind = "agent" | "compaction" | "session-title" | "one-shot" | "unknown";
+/** Provider-reported disjoint token buckets. */
+export interface ProviderUsageTelemetry {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cacheReadTokens: number;
+    readonly cacheWriteTokens: number;
+    readonly reasoningTokens?: number;
+}
+/** Derived wire-boundary token-volume metrics. */
+export interface DerivedUsageTelemetry {
+    readonly effectiveInputTokens: number;
+}
+/** Terminal result of one observed model call. */
+export type CallResult = {
+    readonly kind: "success";
+} | {
+    readonly kind: "error";
+    readonly code?: string;
+} | {
+    readonly kind: "aborted";
+};
+/** Secret-free telemetry for one request routed through an optimizer alias. */
+export interface OptimizerCallTelemetry {
+    readonly schemaVersion: 1;
+    readonly callId: string;
+    readonly sessionId?: string;
+    readonly kind: RequestKind;
+    readonly provider: string;
+    readonly model: string;
+    readonly optimizer: "sleev";
+    readonly startedAt: number;
+    readonly finishedAt: number;
+    readonly durationMs: number;
+    readonly providerUsage?: ProviderUsageTelemetry;
+    readonly derived?: DerivedUsageTelemetry;
+    readonly result: CallResult;
+}
+//# sourceMappingURL=telemetry.d.ts.map

package/package.json

@@ -0,0 +1,124 @@
+{
+  "name": "@yadsh/dsh-sleev",
+  "version": "0.0.1",
+  "description": "Sleev routing observability for DeepSeek Harness",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xarleyn/dsh-plugins.git",
+    "directory": "plugins/dsh-sleev"
+  },
+  "homepage": "https://github.com/xarleyn/dsh-plugins/tree/main/plugins/dsh-sleev#readme",
+  "bugs": {
+    "url": "https://github.com/xarleyn/dsh-plugins/issues"
+  },
+  "type": "module",
+  "main": "./lib/index.js",
+  "types": "./lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./telemetry": {
+      "types": "./lib/types/shared/telemetry.d.ts",
+      "default": "./lib/shared/telemetry.js"
+    },
+    "./sleev": {
+      "types": "./lib/types/host/optimizer/sleev/headers.d.ts",
+      "default": "./lib/host/optimizer/sleev/headers.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-settings-plugins"
+      ],
+      "platform": "web"
+    }
+  },
+  "files": [
+    "lib/**/*.js",
+    "lib/types/**/*.d.ts",
+    "cordis.patch.yml",
+    "docs/*",
+    "README.md",
+    "README.zh-CN.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('lib', { recursive: true, force: true })\"",
+    "lint": "eslint src tests scripts",
+    "format": "prettier --check . --end-of-line auto",
+    "format:write": "prettier --write . --end-of-line auto",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:package": "node scripts/verify-package.mjs",
+    "verify": "pnpm run test:package",
+    "smoke:packed": "node scripts/smoke-packed-dsh.mjs",
+    "build": "pnpm run clean && tsdown && tsc -p tsconfig.build.json",
+    "smoke:neuraldeep": "tsx scripts/smoke-neuraldeep.ts",
+    "check": "pnpm run format && pnpm run typecheck && pnpm run test && pnpm run build && pnpm run test:package",
+    "prepare": "tsdown && tsc -p tsconfig.build.json",
+    "prepublishOnly": "pnpm run check"
+  },
+  "keywords": [
+    "deepseek",
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "sleev",
+    "context-optimization"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "catalog:dsh",
+    "@deepseek-ai/schemastery": "catalog:dsh",
+    "@deepseek-ai/dsh-client-locale": "catalog:dsh",
+    "@deepseek-ai/dsh-client-runtime": "catalog:dsh",
+    "@deepseek-ai/dsh-client-ui-settings": "catalog:dsh",
+    "@deepseek-ai/dsh-client-ui-settings-plugins": "catalog:dsh",
+    "@deepseek-ai/dsh-client-ui-slots": "catalog:dsh",
+    "@deepseek-ai/dsh-llm": "catalog:dsh",
+    "@deepseek-ai/dsh-settings": "catalog:dsh",
+    "react": "^18.2.0"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@deepseek-ai/cordis": "catalog:dsh-dev",
+    "@deepseek-ai/schemastery": "catalog:dsh-dev",
+    "@deepseek-ai/dsh-client-locale": "catalog:dsh-dev",
+    "@deepseek-ai/dsh-client-runtime": "catalog:dsh-dev",
+    "@deepseek-ai/dsh-client-ui-settings": "catalog:dsh-dev",
+    "@deepseek-ai/dsh-client-ui-settings-plugins": "catalog:dsh-dev",
+    "@deepseek-ai/dsh-client-ui-slots": "catalog:dsh-dev",
+    "@deepseek-ai/dsh-llm": "catalog:dsh-dev",
+    "@deepseek-ai/dsh-llm-pi-ai": "catalog:dsh-dev",
+    "@deepseek-ai/dsh-settings": "catalog:dsh-dev",
+    "@types/node": "catalog:tooling",
+    "@types/react": "catalog:frontend-dev",
+    "eslint": "catalog:tooling",
+    "prettier": "catalog:tooling",
+    "react": "catalog:frontend-dev",
+    "tsdown": "catalog:tooling",
+    "tsx": "4.22.4",
+    "typescript": "catalog:plugin-tooling",
+    "vitest": "catalog:tooling"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}