@toddzheng024/dscode-bundle 0.7.26 → 0.7.28

package/vendor/deepseek/types/types.d.ts

@@ -1,178 +1,117 @@
-/**
- * DeepSeek chat-completions wire format (OpenAI-compatible). Types only.
- *
- * Source of truth: the official API docs at
- * `~/repos/deepsuite-docs/apps/docs/docs` (api/create-chat-completion,
- * guides/thinking_mode.mdx, guides/tool_calls.md), cross-checked against
- * live streams from the internal endpoint (2026-06).
- *
- * @module dsh-llm-deepseek/types
- */
-/** Request body for `POST {baseURL}/chat/completions`. */
-export interface WireRequest {
-    model: string;
-    messages: WireMessage[];
-    stream: true;
-    stream_options: {
-        include_usage: true;
-    };
-    /** Thinking-mode toggle (top level, NOT inside extra_body on the wire). */
-    thinking?: {
-        type: 'enabled' | 'disabled';
-    };
-    /** Thinking effort (official levels). */
-    reasoning_effort?: 'low' | 'high' | 'max';
-    tools?: WireTool[];
-    temperature?: number;
-    max_tokens?: number;
+/** Model catalog and request-local dependencies for DeepSeek Messages. */
+import type { ModelModality, SystemPromptUpdate, ResolvedRetryPolicy, ImageAttachmentAccess } from '@deepseek-ai/dsh-llm';
+import type { AttachmentStore, ImageAttachmentRef } from '@deepseek-ai/dsh-attachment';
+import type { CredentialRef } from '@deepseek-ai/dsh-credentials';
+import type { AnonymousUserId } from '@deepseek-ai/dsh-anonymous-user-id';
+import type { DeepSeekLlmApiExtensionRequest, PreparedDeepSeekLlmApiExtensions } from '@deepseek-ai/dsh-deepseek-llm-api-extensions';
+import type { DeepSeekFileStore, DeepSeekFilePolicy } from './file-store.ts';
+/** One optional model entry advertised by the direct-fetch adapter. */
+export interface DeepSeekCatalogModel {
+    /** Wire model id accepted by the configured endpoint. */
+    id: string;
+    /** Selector label; defaults to {@link id}. */
+    name?: string;
+    /** Optional selector detail for deployments with similar model variants. */
+    description?: string;
+    /** Known combined request/response context capacity; omitted when deployment metadata is unavailable. */
+    contextWindow?: number;
+    /** Per-request output cap for this model; omission falls back to the profile's {@link DeepSeekConnectionOptions.maxTokens}. */
+    maxTokens?: number;
+    /** Accepted request modalities; omission is text-only. */
+    inputModalities?: ModelModality[];
     /**
-     * Stop sequences (OpenAI `stop`): generation halts as soon as the model
-     * produces any one of these strings. Mapped from `GenerateOptions.stop`.
+     * Total-pixel budget replacing the published token-grid projection for one
+     * deterministic request preview, or the 512-by-512 `low` preset; omission
+     * projects onto the token grid.
      */
-    stop?: string[];
-}
-/** System-role message: a single string of instructions. */
-export interface WireSystemMessage {
-    role: 'system';
-    content: string;
-}
-/** Text part inside a multimodal user message. */
-export interface WireTextContentPart {
-    type: 'text';
-    text: string;
-}
-/** Files API reference inside a multimodal user message. */
-export interface WireFileContentPart {
-    type: 'file';
-    file_id: string;
-}
-/** Inline base64 data URL inside a multimodal user message. */
-export interface WireImageUrlContentPart {
-    type: 'image_url';
-    image_url: {
-        url: string;
-    };
-}
-/** One image representation accepted by a multimodal user message. */
-export type WireImageContentPart = WireFileContentPart | WireImageUrlContentPart;
-/** Ordered input part accepted by a multimodal user message. */
-export type WireUserContentPart = WireTextContentPart | WireImageContentPart;
-/** User-role message: text-only string or ordered multimodal input. */
-export interface WireUserMessage {
-    role: 'user';
-    content: string | WireUserContentPart[];
-}
-/** Tool-role message: the result of one tool call, keyed by its call id. */
-export interface WireToolMessage {
-    role: 'tool';
-    tool_call_id: string;
-    content: string;
-}
-/** One entry of the request `messages` array, discriminated on `role`. */
-export type WireMessage = WireSystemMessage | WireUserMessage | WireAssistantMessage | WireToolMessage;
-/**
- * Assistant-role history message. The harness replays `content: ""` (never
- * null) on tool-call-only turns — some gateways reject null — and sends null
- * only when the turn carried neither text nor tool calls.
- */
-export interface WireAssistantMessage {
-    role: 'assistant';
-    content: string | null;
+    imagePixelBudget?: number | 'low';
+    /** Encoded-byte target for one deterministic request preview; the smallest quality-ladder output is used when no quality fits. */
+    imageMaxBytes?: number;
     /**
-     * CoT passback, present on every turn whose assistant content carried
-     * reasoning. REQUIRED on tool-call turns in thinking mode (see
-     * guides/thinking_mode.mdx § Tool Calls); DeepSeek ignores it elsewhere,
-     * while a gateway re-encoding for another vendor recovers that turn's
-     * thinking signature by hashing it.
+     * `'in-history'` declares that the endpoint reads the latest `system`
+     * message at any position of the conversation as the complete effective
+     * system prompt; omission means only a leading system message is read.
      */
-    reasoning_content?: string;
-    tool_calls?: WireToolCall[];
+    systemPromptUpdate?: SystemPromptUpdate;
 }
-/** A completed tool call replayed on an assistant history message; `arguments` is the raw JSON string. */
-export interface WireToolCall {
-    id: string;
-    type: 'function';
-    function: {
-        name: string;
-        arguments: string;
-    };
-}
-/** One entry of the request `tools` array; `parameters` is a JSON Schema object. */
-export interface WireTool {
-    type: 'function';
-    function: {
-        name: string;
-        description: string;
-        parameters: Record<string, unknown>;
-    };
-}
-/** One parsed SSE `data:` payload (a chat.completion.chunk). */
-export interface WireChunk {
-    choices?: WireChoice[];
-    /** Arrives attached to the finish chunk and/or as a trailing usage-only chunk. */
-    usage?: WireUsage | null;
-}
-/** One streamed choice (requests always ask for a single one); `finish_reason` is non-null only on its terminal chunk. */
-export interface WireChoice {
-    delta?: WireDelta;
-    finish_reason?: string | null;
-}
-/** The incremental content of one streamed choice; any subset of fields may be present per chunk. */
-export interface WireDelta {
-    role?: string;
-    /** Visible text. Null/empty on reasoning/tool-call chunks. */
-    content?: string | null;
+/**
+ * Validated connection facts for one operation. The plugin's
+ * `resolveAdapterOptions` is the one explicit resolve step producing this
+ * shape; the adapter trusts it and re-reads it per operation, which is what
+ * makes a configuration change reach the next request without re-registration.
+ */
+export interface DeepSeekConnectionOptions {
+    /** Messages API root; custom paths remain unchanged. */
+    baseURL: string;
     /**
-     * Thinking-mode CoT. The FIRST chunk carries an empty string (must not
-     * open a reasoning block); absent entirely in non-thinking mode.
+     * Credential reference of this same resolution, resolved per request.
+     * Travelling with the endpoint is the point: a request can never pair one
+     * generation's URL with another generation's secret. Configuration carries
+     * only this name — a literal key is not a configuration value.
      */
-    reasoning_content?: string | null;
-    tool_calls?: WireToolCallDelta[];
-}
-/** A streamed fragment of one tool call; fragments sharing an `index` concatenate into one call. */
-export interface WireToolCallDelta {
-    /** Disambiguates parallel tool calls; stable across a call's deltas. */
-    index: number;
+    apiKeyEnv: CredentialRef;
+    /** Request defaults applied to every call (thinking mode, effort). */
+    defaults: RequestDefaults;
+    /** Default per-request output cap; explicit request values win. */
+    maxTokens: number;
+    /** Positive context capacity used when the selected model has no exact value. */
+    defaultContextWindow: number;
+    /** Advisory models exposed to discovery consumers; requests remain unrestricted. */
+    models: readonly DeepSeekCatalogModel[];
+    /** Maximum provider idle time while one stream read is outstanding. */
+    streamIdleTimeoutMs: number;
+    /** Maximum accumulated file-referenced image bytes in one request. */
+    maxRequestFilesBytes: number;
+    /** Maximum accumulated base64 image payload after Files API fallback. */
+    maxInlineRequestImageBytes: number;
+    /** Maximum number of represented images in one request. */
+    maxImagesPerRequest: number;
+    /** Raw-byte removal step after the file-reference bound is exceeded. */
+    imageOffloadByteQuantum: number;
+    /** Base64-byte removal step after the inline fallback bound is exceeded. */
+    inlineImageOffloadByteQuantum: number;
+    /** Image-count removal step after the count bound is exceeded. */
+    imageOffloadCountQuantum: number;
+    /** Maximum duration of one request-image Files API resolution. */
+    filesApiTimeoutMs: number;
+    /** Upload expiry, refresh, and quota-recovery policy. */
+    filePolicy: DeepSeekFilePolicy;
+    /** Provider-owned model-request retry policy, already resolved. */
+    retryPolicy: ResolvedRetryPolicy;
+}
+/** Constructor options for {@link DeepSeekAdapter}: the operation-local resolution hooks the plugin owns. */
+export interface DeepSeekAdapterOptions {
+    /** Report unusable native Messages replay metadata without exposing content or signatures. */
+    onReplayDegrade?: (detail: {
+        provider: string;
+        model: string;
+        reason: string;
+    }) => void;
+    /** Current validated connection facts; called once per operation. */
+    options: () => DeepSeekConnectionOptions;
     /**
-     * Carried by the first delta of each call. Gateways observed in the wild
-     * repeat it on continuation deltas as `''` or `null`; both mean "unchanged".
+     * Resolve the API key for the connection facts of one request. The
+     * snapshot is passed in — never re-read — so the key can only ever come
+     * from the same resolution as the endpoint it is sent to. Throws `LlmError`
+     * `MISSING_CREDENTIAL` when no key is available anywhere.
      */
-    id?: string | null;
-    type?: 'function';
-    function?: {
-        /** Carried by the first delta of each call, with the same `''`/`null` repetition as {@link WireToolCallDelta.id}. */
-        name?: string | null;
-        /** Argument JSON fragment (concatenate across deltas). */
-        arguments?: string | null;
-    };
-}
-/**
- * Wire token accounting. `prompt_tokens` INCLUDES cache hits (it equals
- * `prompt_cache_hit_tokens + prompt_cache_miss_tokens`); `mapUsage` subtracts
- * them to keep the harness convention of disjoint counts.
- * `prompt_tokens_details.cached_tokens` is the OpenAI-compat spelling of the
- * hit count.
- */
-export interface WireUsage {
-    prompt_tokens: number;
-    completion_tokens: number;
-    /** Provider-reported aggregate across prompt and completion tokens. */
-    total_tokens?: number;
-    prompt_cache_hit_tokens?: number;
-    prompt_cache_miss_tokens?: number;
-    prompt_tokens_details?: {
-        cached_tokens?: number;
-    };
-    completion_tokens_details?: {
-        reasoning_tokens?: number;
-    };
-}
-/** Non-2xx error body. */
-export interface WireError {
-    error?: {
-        message?: string;
-        type?: string;
-        code?: string;
-    };
+    resolveApiKey: (connection: DeepSeekConnectionOptions) => Promise<string>;
+    /** Resolve a DSH account token only for an eligible official endpoint. */
+    resolveAccountToken?: (connection: DeepSeekConnectionOptions) => Promise<string | undefined>;
+    /** Resolve the harness-home anonymous id shared with telemetry and feedback. */
+    resolveUserId: () => AnonymousUserId;
+    /** Resolve the current durable attachment service; absence rejects image input. */
+    resolveAttachments?: () => AttachmentStore | undefined;
+    /** Bridge one attachment reference into the current model-tool execution world. */
+    resolveImageAccess?: (attachments: AttachmentStore, ref: ImageAttachmentRef) => ImageAttachmentAccess | undefined;
+    /** Resolve the process-wide upload reuse store. */
+    resolveFiles?: () => DeepSeekFileStore;
+    /** Prepare the official API's plugin-contributed top-level fields for one exact wire request. */
+    prepareExtensions: (request: DeepSeekLlmApiExtensionRequest) => Promise<PreparedDeepSeekLlmApiExtensions>;
+}
+/** Adapter-level request defaults (from plugin config). */
+export interface RequestDefaults {
+    thinking?: 'enabled' | 'disabled' | undefined;
+    reasoningEffort?: 'off' | 'low' | 'high' | 'max' | undefined;
 }
 //# sourceMappingURL=types.d.ts.map

package/vendor/deepseek/types/wire-types.d.ts

@@ -0,0 +1,62 @@
+/** DeepSeek's supported subset of the Anthropic Messages request protocol. */
+/** Text and inline or file-referenced images accepted in user messages and tool results. */
+export type WireInput = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    source: {
+        type: 'base64';
+        media_type: string;
+        data: string;
+    };
+} | {
+    type: 'image';
+    source: {
+        type: 'file';
+        file_id: string;
+    };
+};
+/** Content serialized into one Messages conversation turn. */
+export type WireBlock = WireInput | {
+    type: 'thinking';
+    thinking: string;
+    signature?: string;
+} | {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+} | {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: WireInput[];
+    is_error?: boolean;
+};
+/** Conversation turn; capable routes retain later system updates in message history. */
+export type WireMessage = {
+    role: 'user' | 'assistant' | 'system';
+    content: WireBlock[];
+};
+/** JSON body submitted to the resolved Messages endpoint. */
+export type WireRequest = {
+    model: string;
+    stream: true;
+    max_tokens: number;
+    messages: WireMessage[];
+    system?: string;
+    thinking: {
+        type: 'enabled' | 'disabled';
+    };
+    output_config?: {
+        effort: 'low' | 'high' | 'max';
+    };
+    temperature?: number;
+    stop_sequences?: string[];
+    tools?: {
+        name: string;
+        description: string;
+        input_schema: Record<string, unknown>;
+    }[];
+};
+//# sourceMappingURL=wire-types.d.ts.map

package/vendor/persistent/index.js

@@ -257,7 +257,13 @@ async function executeCommand(ctx, shells, owner, command, config, upstream) {
 	};
 	try {
 		const commandDeadline = __addDisposableResource(env_1, deadline(upstream, config.timeoutMs, TIMEOUT_CODE), false);
-		const id = await shells.get(owner, commandDeadline.signal);
+		let id;
+		try {
+			id = await shells.get(owner, commandDeadline.signal);
+		} catch (error) {
+			if (upstream.aborted && error === upstream.reason) return "";
+			throw error;
+		}
 		const marker = markers();
 		const wrapped = wrapCommand(command, marker);
 		const startedAt = Date.now();
@@ -301,7 +307,7 @@ async function executeCommand(ctx, shells, owner, command, config, upstream) {
 			}
 			if (commandDeadline.signal.aborted) {
 				await shells.reset(owner, "persistent bash command aborted");
-				commandDeadline.signal.throwIfAborted();
+				return "";
 			}
 			if (captured.text.includes(marker.end)) {
 				const complete = commandOutput(captured, marker);
@@ -367,7 +373,7 @@ function registerPersistentBash(ctx, config) {
 			const owner = exec.agent;
 			if (owner === void 0) throw new Error("bash requires an owning agent session");
 			return serialized(owner, async () => {
-				exec.signal.throwIfAborted();
+				if (exec.signal.aborted) return "";
 				return executeCommand(ctx, shells, owner, args.command, config, exec.signal);
 			});
 		},

package/vendor/subagent/index.js

@@ -270,7 +270,7 @@ const Config = z.object({
 		allow: z.array(z.string()).default(void 0),
 		deny: z.array(z.string()).default(void 0)
 	}).default(void 0),
-	maxDepth: z.union([z.natural().max(Number.MAX_SAFE_INTEGER), z.const("provider-managed")]).default(3)
+	maxDepth: z.union([z.natural().max(Number.MAX_SAFE_INTEGER), z.const("provider-managed")])
 });
 /** Render text blocks from the canonical JSON block array without trusting arbitrary values. */
 function outputValueText(values) {
@@ -378,7 +378,7 @@ function apply(ctx, config, session) {
 	const modelSelectionCapable = config.modelSelectionSettings === true;
 	ctx.sessionProjections.register(subagentModelSelectionProjectionDefinition);
 	const assertSubagentProviderConfiguration = (subagentProvider) => {
-		if (typeof config.maxDepth === "number" && !subagentProvider.capabilities.depthLimit) throw new Error(`tool-subagent: provider "${subagentProvider.name}" cannot enforce maxDepth (no depthLimit capability) — set maxDepth: 'provider-managed' to leave the recursion budget to the provider`);
+		if (ctx.subagents.resolveMaxDepth(config.maxDepth) !== void 0 && !subagentProvider.capabilities.depthLimit) throw new Error(`tool-subagent: provider "${subagentProvider.name}" cannot enforce maxDepth (no depthLimit capability) — set maxDepth: 'provider-managed' to leave the recursion budget to the provider`);
 		if (config.agentOptions !== void 0 && !subagentProvider.capabilities.agentOptions) throw new Error(`tool-subagent: provider "${subagentProvider.name}" does not support child agentOptions`);
 		if (modelSelectionCapable && !subagentProvider.capabilities.agentOptions) throw new Error(`tool-subagent: provider "${subagentProvider.name}" does not support child model selection`);
 		if (continuable && subagentProvider.prepareContinuable === void 0) throw new Error(`tool-subagent: provider "${subagentProvider.name}" does not support \`backgroundMode: continuable\``);
@@ -401,7 +401,7 @@ function apply(ctx, config, session) {
 				subagentProvider,
 				disposeTool: runtimeCtx.tools.register(defineTool({
 					name: toolName,
-					description: wording.description + (backgroundEnabled ? continuable ? " This tool runs in the background by default, immediately returns a durable subagent id, and keeps the child conversation available for later turns. When that run settles, the runtime sends the parent a notice containing its outcome and any final assistant message; `send_message` steers the child's nearest step while it is running and starts a turn while it is idle. Set `run_in_background: false` only when your next action depends on receiving the result." : " This call waits for the result by default. Set `run_in_background: true` to return a job id; collect with `job_output` and stop with `job_kill`." : " This call waits for the subagent and returns its result.") + choiceDescription + (continuable && (config.provider === "spawn" || config.provider === "fork") ? " Set worktree: true for an isolated Git checkout when agents edit in parallel. It starts at HEAD and refuses a dirty parent workspace; omit for read-only tasks or when the child needs uncommitted parent edits. You must inspect and integrate its changes; the worktree remains after completion." : ""),
+					description: wording.description + (backgroundEnabled ? continuable ? " This tool runs in the background by default, immediately returns a durable subagent id, and keeps the child conversation available for later turns. When that run settles, the runtime sends the parent a notice containing its outcome and any final assistant message; `send_message` steers the child's nearest step while it is running and starts or resumes a turn while it is inactive. Set `run_in_background: false` only when your next action depends on receiving the result." : " This call waits for the result by default. Set `run_in_background: true` to return a job id; collect with `job_output` and stop with `job_kill`." : " This call waits for the subagent and returns its result.") + choiceDescription + (continuable && (config.provider === "spawn" || config.provider === "fork") ? " Set worktree: true for an isolated Git checkout when agents edit in parallel. It starts at HEAD and refuses a dirty parent workspace; omit for read-only tasks or when the child needs uncommitted parent edits. You must inspect and integrate its changes; the worktree remains after completion." : ""),
 					parameters: {
 						name: {
 							type: "string",
@@ -530,7 +530,7 @@ Inspect and integrate its changes before removing it.` : "")
 						exec.signal.throwIfAborted();
 						if (args.worktree === true && !(continuable && (config.provider === "spawn" || config.provider === "fork"))) throw new Error("worktree is unavailable for this subagent provider");
 						const childWorktree = args.worktree === true ? await createChildWorktree(parent.session.header.cwd, exec.signal) : void 0;
-						const maxDepth = typeof config.maxDepth === "number" ? config.maxDepth : void 0;
+						const maxDepth = runtimeCtx.subagents.resolveMaxDepth(config.maxDepth);
 						const request = {
 							label: "/" + args.name + " · " + args.description,
 							...childWorktree ? { workspaceCwd: childWorktree.cwd } : {},
@@ -566,7 +566,7 @@ Inspect and integrate its changes before removing it.` : "")
 								jobId: jobs.start({
 									kind: "subagent",
 									label: "/" + args.name + " · " + args.description,
-									owner: parent,
+									owner: parent.id,
 									run: () => {
 										const controller = new AbortController();
 										return {
@@ -648,7 +648,9 @@ Inspect and integrate its changes before removing it.` : "")
 	const installing = /* @__PURE__ */ new WeakSet();
 	const belongsToComposition = (candidate) => scopeChainOf(scopeOf(candidate.ctx)).includes(compositionScope);
 	const installScoped = (candidate) => {
-		if (scopedInstalls.has(candidate) || installing.has(candidate)) return;
+		const existing = scopedInstalls.get(candidate);
+		if (existing !== void 0) return existing;
+		if (installing.has(candidate)) return;
 		installing.add(candidate);
 		let fiber;
 		try {
@@ -664,6 +666,7 @@ Inspect and integrate its changes before removing it.` : "")
 			installing.delete(candidate);
 		}
 		scopedInstalls.set(candidate, fiber);
+		return fiber;
 	};
 	const removeScoped = (candidate) => {
 		const fiber = scopedInstalls.get(candidate);
@@ -678,8 +681,8 @@ Inspect and integrate its changes before removing it.` : "")
 		for (const candidate of agents.list()) if (belongsToComposition(candidate)) installScoped(candidate);
 		else removeScoped(candidate);
 	};
-	ctx.on("agent/created", ({ agent: created }) => {
-		installScoped(created);
+	ctx.on("agent/created", async ({ agent: created }) => {
+		await installScoped(created);
 	});
 	ctx.on("agent/disposed", ({ agent: disposed }) => {
 		removeScoped(disposed);

package/vendor/subagent/model-selection-settings.js

@@ -37,58 +37,32 @@ function assertAllowedModelRoutes(routes) {
 }
 //#endregion
 //#region lib/types/model-selection-settings.js
-/** Host-owned opt-in setting for model-selectable subagent delegation. */
-/** User-settings section for model-selectable subagent delegation. */
-const SUBAGENT_MODEL_SELECTION_SETTINGS_NAMESPACE = "subagent-model-selection";
-/** Schema served to settings clients for the opt-in preference. */
-const SUBAGENT_MODEL_SELECTION_SETTINGS_SCHEMA = z.object({
-	enabled: z.boolean().default(false),
-	allowedModels: z.array(AllowedModelRouteSchema).default([])
-});
 /** Singleton settings owner read when delegation tools are composed for a Session. */
 var SubagentModelSelectionConfig = class extends Service {
+	config;
 	static Config = z.object({
-		enabled: z.boolean().default(false),
-		allowedModels: z.array(AllowedModelRouteSchema).default([])
+		enabled: z.boolean().default(false).volatile(),
+		allowedModels: z.array(AllowedModelRouteSchema).default([]).volatile()
 	});
-	source;
-	constructor(ctx, config = {}) {
+	constructor(ctx, config) {
 		super(ctx, "subagentModelSelection");
-		/* v8 ignore next */
-		const entry = {
-			enabled: config.enabled ?? false,
-			allowedModels: config.allowedModels ?? []
-		};
-		this.validate(entry);
-		this.source = () => entry;
-		ctx.inject(["settings"], (settingsCtx) => {
-			settingsCtx.settings.installSection(ctx, SUBAGENT_MODEL_SELECTION_SETTINGS_NAMESPACE, SUBAGENT_MODEL_SELECTION_SETTINGS_SCHEMA, entry, {
-				setSource: (source) => {
-					this.source = source;
-				},
-				validate: (value) => {
-					this.validate(value);
-				},
-				onChange: () => {}
-			});
-		});
+		this.config = config;
 	}
 	/**
 	* Read a detached selection preference for the next eligible Session composition.
 	* @returns the enabled state and exact allowed routes.
 	*/
 	current() {
-		const current = this.source();
+		const enabled = this.config.enabled.get();
+		const allowedModels = this.config.allowedModels.get();
+		assertAllowedModelRoutes(allowedModels);
+		if (enabled && allowedModels.length === 0) throw new Error("enabled subagent model selection requires at least one allowed model");
 		return {
-			enabled: current.enabled,
-			allowedModels: current.allowedModels.map((route) => ({ ...route }))
+			enabled,
+			allowedModels: allowedModels.map((route) => ({ ...route }))
 		};
 	}
-	validate(value) {
-		assertAllowedModelRoutes(value.allowedModels);
-		if (value.enabled && value.allowedModels.length === 0) throw new Error("enabled subagent model selection requires at least one allowed model");
-	}
 };
 const name = "subagent-model-selection-settings";
 //#endregion
-export { SUBAGENT_MODEL_SELECTION_SETTINGS_NAMESPACE, SUBAGENT_MODEL_SELECTION_SETTINGS_SCHEMA, SubagentModelSelectionConfig, SubagentModelSelectionConfig as default, name };
+export { SubagentModelSelectionConfig, SubagentModelSelectionConfig as default, name };

package/vendor/subagent/types/index.d.ts

@@ -60,13 +60,14 @@ export interface Config {
         deny?: string[];
     };
     /**
-     * Maximum child depth: a non-negative safe integer (default `3`; `0` forbids
-     * delegation entirely), or `'provider-managed'` to send no cap. A numeric cap
+     * Maximum child depth: a non-negative safe integer (`0` forbids delegation),
+     * or `'provider-managed'` to send no cap. A numeric cap
      * requires the provider's `depthLimit` capability (mount fails loud
      * otherwise). The provider checks the calling agent's current depth at every
      * start; the tool remains model-visible so runtime policy owns rejection.
      * `'provider-managed'` is for an out-of-process provider whose recursion
-     * budget belongs to the child runtime or its own deployment.
+     * budget belongs to the child runtime or its own deployment. Omission reads
+     * the current Host subagent depth setting (default `1`) at each delegation.
      */
     maxDepth?: number | 'provider-managed';
 }

package/vendor/subagent/types/model-selection-settings.d.ts

@@ -1,4 +1,5 @@
 /** Host-owned opt-in setting for model-selectable subagent delegation. */
+import type { Volatile } from '@deepseek-ai/cordis';
 import { Context, Service } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
 import { type AllowedModelRoute } from './model-selection.ts';
@@ -8,8 +9,6 @@ declare module '@deepseek-ai/cordis' {
         subagentModelSelection: SubagentModelSelectionConfig;
     }
 }
-/** User-settings section for model-selectable subagent delegation. */
-export declare const SUBAGENT_MODEL_SELECTION_SETTINGS_NAMESPACE = "subagent-model-selection";
 /** Stored user preference; the shipped composition defaults it off. */
 export interface SubagentModelSelectionSettings {
     /** Whether newly composed top-level Sessions receive model selection. */
@@ -17,26 +16,29 @@ export interface SubagentModelSelectionSettings {
     /** Exact child LLM routes offered to newly composed top-level Sessions. */
     allowedModels: AllowedModelRoute[];
 }
-/** Schema served to settings clients for the opt-in preference. */
-export declare const SUBAGENT_MODEL_SELECTION_SETTINGS_SCHEMA: z<SubagentModelSelectionSettings>;
 /** Optional deployment base for the preference. */
 export interface Config {
     /** Initial enabled state inherited when the user document does not override it. */
-    enabled?: boolean;
+    enabled: Volatile<boolean>;
     /** Initial route list inherited when the user document does not override it. */
-    allowedModels?: AllowedModelRoute[];
+    allowedModels: Volatile<AllowedModelRoute[]>;
 }
 /** Singleton settings owner read when delegation tools are composed for a Session. */
 export declare class SubagentModelSelectionConfig extends Service {
-    static Config: z<Config>;
-    private source;
-    constructor(ctx: Context, config?: Config);
+    private config;
+    static Config: z<Schemastery.ObjectS<NoInfer<{
+        enabled: z<boolean, boolean, "volatile-defined">;
+        allowedModels: z<NoInfer<AllowedModelRoute[]>, NoInfer<AllowedModelRoute[]>, "volatile-defined">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        enabled: z<boolean, boolean, "volatile-defined">;
+        allowedModels: z<NoInfer<AllowedModelRoute[]>, NoInfer<AllowedModelRoute[]>, "volatile-defined">;
+    }>>, "plain">;
+    constructor(ctx: Context, config: Config);
     /**
      * Read a detached selection preference for the next eligible Session composition.
      * @returns the enabled state and exact allowed routes.
      */
     current(): SubagentModelSelectionSettings;
-    private validate;
 }
 export declare const name = "subagent-model-selection-settings";
 export default SubagentModelSelectionConfig;