super-dsh 0.1.12 → 0.3.0

package/node_modules/better-dsh/lib/compaction/index.d.ts

@@ -0,0 +1,57 @@
+import { t as Schema } from "../index-DTDXUe6m.js";
+import { Context, Volatile } from "@deepseek-ai/cordis";
+
+//#region src/compaction/config.d.ts
+
+/** The `compaction-tuning` settings value. */
+interface CompactionTuningConfig {
+  /** Condense at `floor(routedContextWindow x thresholdRatio)`. */
+  thresholdRatio: number;
+  /** Verbatim recent tail, in estimated tokens. */
+  retainTokens: number;
+}
+//#endregion
+//#region src/compaction/index.d.ts
+
+/** Cordis plugin name. */
+declare const name = "dashr-compaction-tuning";
+/**
+ * No static injects: both `settings` and `compaction` are composed
+ * conditionally inside {@link installCompactionTuning}, so the row loads
+ * (dormant) in compositions without them.
+ */
+declare const inject: string[];
+/**
+ * The row settings schema.
+ *
+ * `thresholdRatio` is the field the General row drives and is volatile (dsh
+ * 0.1.7 settings model): editing it from Settings lands as a profile-layer
+ * patch override on this row and the resolved ref rewrites in place.
+ * `retainTokens` is composition-only (see {@link DEFAULT_RETAIN_TOKENS}) and
+ * stays non-volatile — form writes never touch it, a patch file still can.
+ */
+declare const Config: Schema<CompactionTuningConfig>;
+/**
+ * The row config as cordis hands it over post-resolution: the volatile
+ * threshold arrives as a live reference, not a plain number.
+ */
+interface ResolvedCompactionTuningConfig {
+  thresholdRatio: number | Volatile<number>;
+  retainTokens: number;
+}
+/**
+ * Keep the live compaction engine on the user's threshold preference.
+ * @param ctx - host context of the row that owns this capability.
+ * @param config - resolved row config; the volatile threshold is a live ref.
+ */
+declare function installCompactionTuning(ctx: Context, config?: ResolvedCompactionTuningConfig): void;
+/** Mount the tuning as the row's whole apply (the row config is the settings base). */
+declare function apply(ctx: Context, config: ResolvedCompactionTuningConfig | undefined): void;
+declare const _default: {
+  name: string;
+  inject: string[];
+  Config: Schema<CompactionTuningConfig>;
+  apply: typeof apply;
+};
+//#endregion
+export { Config, ResolvedCompactionTuningConfig, apply, _default as default, inject, installCompactionTuning, name };

package/node_modules/better-dsh/lib/compaction/index.js

@@ -0,0 +1,145 @@
+import { t as Schema } from "../lib-C8_jXvwA.js";
+import { Context } from "@deepseek-ai/cordis";
+
+//#region src/compaction/config.ts
+/** Upstream `compaction-basic`'s own default: condense at 80% of the window. */
+const DEFAULT_THRESHOLD_RATIO = .8;
+/**
+* Absolute recent-tail budget, in estimated tokens (~50 KB of English text).
+*
+* Composition-only, deliberately: the General row drives `thresholdRatio`
+* alone, so the recency window stays a deployment decision (its base layer is
+* the row config in `cordis.patch.yml`) rather than a second knob on the
+* settings page. The host half still applies it to the engine.
+*/
+const DEFAULT_RETAIN_TOKENS = 5e4;
+/** Ratio bounds the settings schema accepts (a config file may use either end). */
+const THRESHOLD_MIN_RATIO = .05;
+/** @see THRESHOLD_MIN_RATIO */
+const THRESHOLD_MAX_RATIO = 1;
+/** Spec defaults — `Config({})` must equal this. */
+const defaultCompactionTuningConfig = {
+	thresholdRatio: DEFAULT_THRESHOLD_RATIO,
+	retainTokens: DEFAULT_RETAIN_TOKENS
+};
+
+//#endregion
+//#region src/compaction/index.ts
+/** Cordis plugin name. */
+const name = "dashr-compaction-tuning";
+/**
+* No static injects: both `settings` and `compaction` are composed
+* conditionally inside {@link installCompactionTuning}, so the row loads
+* (dormant) in compositions without them.
+*/
+const inject = [];
+/**
+* The row settings schema.
+*
+* `thresholdRatio` is the field the General row drives and is volatile (dsh
+* 0.1.7 settings model): editing it from Settings lands as a profile-layer
+* patch override on this row and the resolved ref rewrites in place.
+* `retainTokens` is composition-only (see {@link DEFAULT_RETAIN_TOKENS}) and
+* stays non-volatile — form writes never touch it, a patch file still can.
+*/
+const Config = Schema.object({
+	thresholdRatio: Schema.number().step(.01).min(THRESHOLD_MIN_RATIO).max(THRESHOLD_MAX_RATIO).default(DEFAULT_THRESHOLD_RATIO).volatile(),
+	retainTokens: Schema.number().step(1).min(0).default(DEFAULT_RETAIN_TOKENS)
+});
+/**
+* Keep the live compaction engine on the user's threshold preference.
+* @param ctx - host context of the row that owns this capability.
+* @param config - resolved row config; the volatile threshold is a live ref.
+*/
+function installCompactionTuning(ctx, config = defaultCompactionTuningConfig) {
+	const logger = ctx.logger("compaction-tuning");
+	const live = () => ({
+		thresholdRatio: typeof config.thresholdRatio === "number" ? config.thresholdRatio : config.thresholdRatio.get() ?? DEFAULT_THRESHOLD_RATIO,
+		retainTokens: config.retainTokens
+	});
+	/** Smallest routed context window seen so far (advisory guard, best effort). */
+	let minWindow;
+	let probing = false;
+	/**
+	* Learn the routed context windows and log when the current pairing would
+	* leave `retainTokens >= floor(window x thresholdRatio)` — the condition
+	* under which the engine raises `TargetPressureConfigError` per route and
+	* automatic condensation quietly stops for that route. Advisory only: the
+	* dsh 0.1.7 settings model has no custom write-validation seam, so a bad
+	* pairing surfaces through the engine's own per-route error instead.
+	*/
+	const probeWindows = () => {
+		if (probing || minWindow !== void 0) return;
+		const llm = ctx.get("llm");
+		if (llm === void 0) return;
+		probing = true;
+		(async () => {
+			try {
+				let smallest;
+				for (const provider of llm.listProviders()) for (const model of await llm.listModels(provider.id)) {
+					const window = (await llm.resolveModelInfo(provider.id, model.id)).context?.contextWindow;
+					if (typeof window !== "number" || window <= 0) continue;
+					smallest = smallest === void 0 ? window : Math.min(smallest, window);
+				}
+				if (smallest !== void 0) {
+					minWindow = smallest;
+					const value = live();
+					const thresholdTokens = Math.floor(smallest * value.thresholdRatio);
+					if (value.retainTokens >= thresholdTokens) logger.warn(`retainTokens (${value.retainTokens}) is at or above the threshold tokens for the smallest routed window (${smallest} x ${value.thresholdRatio} = ${thresholdTokens}); automatic condensation will error per route until the threshold rises`);
+					else logger.info(`smallest routed context window: ${smallest} tokens`);
+				}
+			} catch (error) {
+				logger.warn(`context-window probe failed (retention guard disabled): ${error instanceof Error ? error.message : String(error)}`);
+			} finally {
+				probing = false;
+			}
+		})();
+	};
+	/**
+	* Hand the engine a frozen policy view carrying THIS module's two fields as
+	* getters over the live refs: every engine policy re-read (per event) sees
+	* the current General-row value with no re-apply step. Every other policy
+	* field is carried over verbatim; `retainRatio` is dropped whenever the
+	* absolute `retainTokens` is in force, because the engine treats the two as
+	* mutually exclusive. Idempotent — re-run when the engine mounts late.
+	*/
+	const installLivePolicy = (reason) => {
+		const compaction = ctx.get("compaction");
+		if (compaction === void 0) return;
+		const base = compaction.config;
+		if (base === void 0) return;
+		const current = live();
+		const view = {
+			...base,
+			get thresholdRatio() {
+				return live().thresholdRatio;
+			},
+			get retainTokens() {
+				return live().retainTokens;
+			}
+		};
+		delete view.retainRatio;
+		compaction.config = Object.freeze(view);
+		logger.info(`live policy installed (${reason}): thresholdRatio=${current.thresholdRatio} retainTokens=${current.retainTokens}`);
+	};
+	ctx.inject(["compaction"], () => {
+		installLivePolicy("compaction-ready");
+		probeWindows();
+	});
+	ctx.inject(["settings"], (child) => {
+		child.effect(() => child.settings.configure({ auto: false }, ctx.fiber));
+	});
+}
+/** Mount the tuning as the row's whole apply (the row config is the settings base). */
+function apply(ctx, config) {
+	installCompactionTuning(ctx, config ?? defaultCompactionTuningConfig);
+}
+var compaction_default = {
+	name,
+	inject,
+	Config,
+	apply
+};
+
+//#endregion
+export { Config, apply, compaction_default as default, inject, installCompactionTuning, name };

package/node_modules/better-dsh/lib/failover/index.d.ts

@@ -0,0 +1,59 @@
+import { t as Schema } from "../index-DTDXUe6m.js";
+import { Context, Volatile } from "@deepseek-ai/cordis";
+
+//#region src/failover/config.d.ts
+
+/** The fallback chain: two ordered slots. `''` = not set (skip). */
+interface FailoverConfig {
+  fallback1: string;
+  fallback2: string;
+}
+//#endregion
+//#region src/failover/index.d.ts
+
+/** Cordis plugin name. */
+declare const name = "dashr-failover";
+/**
+ * No static injects: `settings` is composed conditionally inside
+ * {@link installFailover} (`ctx.inject(['settings'], …)`), so the row loads
+ * (dormant) in compositions without a settings service.
+ */
+declare const inject: string[];
+/**
+ * The row settings schema: two optional fallback slots, both default "not set".
+ *
+ * Both fields are volatile (dsh 0.1.7 settings model): the settings General
+ * row edits them live through `remote.settings` — the write lands as a
+ * profile-layer patch override on THIS row's entry, the runtime rewrites the
+ * resolved refs in place, and every request re-reads them without a reload.
+ */
+declare const Config: Schema<FailoverConfig>;
+/**
+ * The row config as cordis hands it over post-resolution: volatile fields are
+ * live references, not plain strings.
+ */
+interface ResolvedFailoverConfig {
+  fallback1: string | Volatile<string>;
+  fallback2: string | Volatile<string>;
+}
+/**
+ * Install the failover. A no-op composition degrades gracefully (empty chain = pass-through).
+ *
+ * dsh 0.1.7 settings model: the row entry IS the settings namespace. The
+ * volatile schema fields above make it form-editable through `remote.settings`
+ * (edits persist as a profile-layer patch override via the config editor), the
+ * resolved refs re-read live per request, and the native auto-generated form
+ * is suppressed in favor of this plugin's own General row — the same shape
+ * upstream `agent-default-model` uses for its selection surface.
+ */
+declare function installFailover(ctx: Context, config?: ResolvedFailoverConfig): void;
+/** Mount the failover as the row's whole apply (the row config is the chain base). */
+declare function apply(ctx: Context, config: ResolvedFailoverConfig | undefined): void;
+declare const _default: {
+  name: string;
+  inject: string[];
+  Config: Schema<FailoverConfig>;
+  apply: typeof apply;
+};
+//#endregion
+export { Config, ResolvedFailoverConfig, apply, _default as default, inject, installFailover, name };

package/node_modules/better-dsh/lib/failover/index.js

@@ -0,0 +1,147 @@
+import { t as Schema } from "../lib-C8_jXvwA.js";
+import { randomUUID } from "node:crypto";
+import { Context } from "@deepseek-ai/cordis";
+import { RetryId } from "@deepseek-ai/dsh-llm-retry";
+
+//#region src/failover/config.ts
+/** Failure codes that activate a fallback switch. */
+const FAILOVER_TRIGGER_CODES = {
+	AUTH: true,
+	MISSING_CREDENTIAL: true,
+	QUOTA: true,
+	RATE_LIMIT: true
+};
+/** Spec defaults — `Config({})` must equal this (both slots unset = native behavior). */
+const defaultFailoverConfig = {
+	fallback1: "",
+	fallback2: ""
+};
+/** The non-empty fallback routes in order (at most 2). */
+function fallbackRoutes(config) {
+	return [config.fallback1, config.fallback2].filter((route) => route.length > 0);
+}
+/** Split a `provider/model` route; `undefined` when malformed. */
+function splitRoute(route) {
+	const slash = route.indexOf("/");
+	if (slash <= 0 || slash === route.length - 1) return void 0;
+	return {
+		provider: route.slice(0, slash),
+		model: route.slice(slash + 1)
+	};
+}
+
+//#endregion
+//#region src/failover/index.ts
+/** Cordis plugin name. */
+const name = "dashr-failover";
+/**
+* No static injects: `settings` is composed conditionally inside
+* {@link installFailover} (`ctx.inject(['settings'], …)`), so the row loads
+* (dormant) in compositions without a settings service.
+*/
+const inject = [];
+/**
+* The row settings schema: two optional fallback slots, both default "not set".
+*
+* Both fields are volatile (dsh 0.1.7 settings model): the settings General
+* row edits them live through `remote.settings` — the write lands as a
+* profile-layer patch override on THIS row's entry, the runtime rewrites the
+* resolved refs in place, and every request re-reads them without a reload.
+*/
+const Config = Schema.object({
+	fallback1: Schema.string().default("").volatile(),
+	fallback2: Schema.string().default("").volatile()
+});
+/** Read one field that may be a plain value (tests, defaults) or a live ref (composed row). */
+function readSlot(slot) {
+	if (typeof slot === "string") return slot;
+	const value = slot.get();
+	return typeof value === "string" ? value : "";
+}
+/** Replace provider/model on a request config, dropping the inherited reasoning effort. */
+function overrideConfig(seed, to) {
+	const { reasoningEffort: _inherited,...rest } = seed;
+	return {
+		...rest,
+		provider: to.provider,
+		model: to.model
+	};
+}
+/**
+* Install the failover. A no-op composition degrades gracefully (empty chain = pass-through).
+*
+* dsh 0.1.7 settings model: the row entry IS the settings namespace. The
+* volatile schema fields above make it form-editable through `remote.settings`
+* (edits persist as a profile-layer patch override via the config editor), the
+* resolved refs re-read live per request, and the native auto-generated form
+* is suppressed in favor of this plugin's own General row — the same shape
+* upstream `agent-default-model` uses for its selection surface.
+*/
+function installFailover(ctx, config = defaultFailoverConfig) {
+	const logger = ctx.logger("llm-failover");
+	const source = () => ({
+		fallback1: readSlot(config.fallback1),
+		fallback2: readSlot(config.fallback2)
+	});
+	ctx.inject(["settings"], (child) => {
+		child.effect(() => child.settings.configure({ auto: false }, ctx.fiber));
+	});
+	const latches = /* @__PURE__ */ new Map();
+	ctx.on("agent/disposed", ({ agent }) => {
+		latches.delete(agent.id);
+	});
+	ctx.on("agent/request-error", async ({ agent, turn, step, provider, failure }, next) => {
+		if (FAILOVER_TRIGGER_CODES[failure.code] !== true) return next();
+		const routes = fallbackRoutes(source());
+		if (routes.length === 0) return next();
+		const latch = latches.get(agent.id);
+		const fallbackIndex = latch !== void 0 && latch.turn === turn ? latch.fallbackIndex : 0;
+		if (fallbackIndex >= routes.length) return next();
+		const nextIndex = fallbackIndex + 1;
+		const route = routes[nextIndex - 1];
+		if (splitRoute(route) === void 0) return next();
+		latches.set(agent.id, {
+			turn,
+			fallbackIndex: nextIndex
+		});
+		logger.info("llm-failover: agent \"%s\" provider=\"%s\" code=%s -> switch to \"%s\" (per turn)", agent.id, provider, failure.code, route);
+		agent.session.append("llm/retry", {
+			retryId: RetryId(randomUUID()),
+			turn,
+			step,
+			provider,
+			mode: "normal",
+			policyKey: "llm-failover",
+			retry: nextIndex,
+			maxRetries: routes.length,
+			delayMs: 0,
+			failure: {
+				...failure,
+				code: "failover",
+				message: `[${failure.code}] ${failure.message} → switched to "${route}"`
+			}
+		});
+		return { kind: "retry" };
+	});
+	ctx.on("agent/request", async ({ agent, turn }, next) => {
+		const seed = await next();
+		const latch = latches.get(agent.id);
+		if (latch === void 0 || latch.turn !== turn || latch.fallbackIndex <= 0) return seed;
+		const route = splitRoute(fallbackRoutes(source())[latch.fallbackIndex - 1] ?? "");
+		if (route === void 0) return seed;
+		return overrideConfig(seed, route);
+	});
+}
+/** Mount the failover as the row's whole apply (the row config is the chain base). */
+function apply(ctx, config) {
+	installFailover(ctx, config ?? defaultFailoverConfig);
+}
+var failover_default = {
+	name,
+	inject,
+	Config,
+	apply
+};
+
+//#endregion
+export { Config, apply, failover_default as default, inject, installFailover, name };

package/node_modules/better-dsh/lib/fs-aware/sandbox-plugin.d.ts

@@ -0,0 +1,71 @@
+import { Context } from "@deepseek-ai/cordis";
+import { Config } from "@deepseek-ai/dsh-fs-local";
+
+//#region src/fs-aware/sandbox-plugin.d.ts
+
+/** Module config: the stock LocalConfig fields plus the scheme gate. */
+interface FsAwareConfig extends Config {
+  /** Master gate for scheme interception at the FS layer (default on). */
+  urlSchemes?: boolean;
+}
+/** Structural view of the inherited backend (loose, like the spike's Base). */
+interface BaseView {
+  resolve(path: string, opts?: {
+    cwd?: string;
+    signal?: AbortSignal;
+  }): Promise<{
+    targetKey: string;
+    displayPath: string;
+  }>;
+  stat(target: {
+    targetKey: string;
+  }, signal?: AbortSignal): Promise<unknown>;
+  readText(target: {
+    targetKey: string;
+  }, signal?: AbortSignal): Promise<string>;
+  writeText(target: {
+    targetKey: string;
+  }, ...rest: unknown[]): Promise<unknown>;
+  editText(target: {
+    targetKey: string;
+  }, ...rest: unknown[]): Promise<unknown>;
+}
+declare const Base: abstract new (ctx: Context, config: FsAwareConfig) => BaseView;
+declare class FsAwareSandboxFileSystem extends Base {
+  static inject: string[];
+  private readonly resolver;
+  private readonly schemeResolution;
+  constructor(ctx: Context, config: FsAwareConfig);
+  /**
+   * FS-layer resolver — the SHARED builder from `wrap.ts` (design D2). One
+   * registration source for both FS consumers: this backend and the instance
+   * wrap. (A private duplicate here once drifted — a doubled `dsh` register
+   * and a literal `'http'` that would silently drop `https` if this backend
+   * were ever the outermost layer.) The `ctx`/`agent` handlers it registers
+   * are unreachable here: session-layer schemes are guarded before resolve.
+   */
+  private buildResolver;
+  /** FS-layer resolver env: no live agent — session-layer schemes are excluded upstream. */
+  private envFor;
+  resolve(path: string, opts?: {
+    cwd?: string;
+    signal?: AbortSignal;
+  }): Promise<{
+    targetKey: string;
+    displayPath: string;
+  }>;
+  stat(target: {
+    targetKey: string;
+  }, signal?: AbortSignal): Promise<unknown>;
+  readText(target: {
+    targetKey: string;
+  }, signal?: AbortSignal): Promise<string>;
+  writeText(target: {
+    targetKey: string;
+  }, ...rest: unknown[]): Promise<unknown>;
+  editText(target: {
+    targetKey: string;
+  }, ...rest: unknown[]): Promise<unknown>;
+}
+//#endregion
+export { FsAwareConfig, FsAwareSandboxFileSystem as default };