@toddzheng024/dscode-bundle 0.1.0 → 0.2.0

package/vendor/subagent/invariant.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import "@deepseek-ai/dsh-llm";
+import z$1 from "@deepseek-ai/schemastery";
+z$1.object({
+	provider: z$1.string().min(1).required(),
+	model: z$1.string().min(1).required()
+});
+z.array(z.object({
+	provider: z.string().min(1),
+	model: z.string().min(1)
+}).strict()).min(1).nullable();
+/**
+* Read the exact route list captured for a model-selectable definition.
+* @param projections - registry that owns the policy projection.
+* @param session - session whose durable decision is read.
+* @returns a detached route list, or undefined for the fixed-route definition.
+*/
+function subagentModelSelectionPolicy(projections, session) {
+	return projections.stateOf(session, "subagentModelSelectionPolicy")?.map((route) => ({ ...route }));
+}
+//#endregion
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@deepseek-ai/dsh-tool-subagent`.
+* @module @deepseek-ai/dsh-tool-subagent/invariant
+*/
+const PACKAGE_NAME = "@deepseek-ai/dsh-tool-subagent";
+/** Cordis companion plugin name. */
+const name = "tool-subagent-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/** Assert that model-selectable definitions are complete and reconstructable. */
+const install = Object.assign((ctx, fail) => {
+	ctx.on("agent/pre-step", async ({ agent }, next) => {
+		const schemas = ctx.tools.schemas(agent);
+		const selectable = schemas.some((schema) => {
+			const properties = schema.parameters.properties;
+			return properties?.["provider"] !== void 0 && properties["model"] !== void 0 && properties["reasoning_effort"] !== void 0;
+		});
+		const discoverable = schemas.some((schema) => schema.name === "list_subagent_models");
+		if ((selectable || discoverable) && (subagentModelSelectionPolicy(ctx.sessionProjections, agent.session) === void 0 || !selectable || !discoverable)) fail("model-selectable subagent definitions require a durable policy, route fields, and list_subagent_models");
+		return next();
+	}, { global: true });
+}, { inject: ["tools", "sessionProjections"] });
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

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

@@ -0,0 +1,94 @@
+import { Service } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+import "@deepseek-ai/dsh-llm";
+//#region lib/types/model-selection.js
+/** Schema shared by the Host setting and its deployment base. */
+const AllowedModelRouteSchema = z.object({
+	provider: z.string().min(1).required(),
+	model: z.string().min(1).required()
+});
+/**
+* Stable identity for one provider/model pair.
+* @param route - Exact provider/model route.
+* @returns Opaque key for equality checks.
+*/
+function modelRouteKey(route) {
+	return `${route.provider}\0${route.model}`;
+}
+/**
+* Reject malformed or duplicate route policy entries at a durable or configuration boundary.
+* @param routes - Candidate exact routes to validate.
+* @returns an assertion that the candidate is a validated exact-route array.
+*/
+function assertAllowedModelRoutes(routes) {
+	if (!Array.isArray(routes)) throw new Error("subagent model selection requires an array of routes");
+	const seen = /* @__PURE__ */ new Set();
+	const candidates = routes;
+	for (const candidate of candidates) {
+		if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate) || !("provider" in candidate) || typeof candidate.provider !== "string" || !("model" in candidate) || typeof candidate.model !== "string" || candidate.provider.length === 0 || candidate.model.length === 0) throw new Error("subagent model selection requires non-empty provider and model ids");
+		const route = {
+			provider: candidate.provider,
+			model: candidate.model
+		};
+		const key = modelRouteKey(route);
+		if (seen.has(key)) throw new Error(`subagent model selection repeats route "${route.provider}/${route.model}"`);
+		seen.add(key);
+	}
+}
+//#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 {
+	static Config = z.object({
+		enabled: z.boolean().default(false),
+		allowedModels: z.array(AllowedModelRouteSchema).default([])
+	});
+	source;
+	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: () => {}
+			});
+		});
+	}
+	/**
+	* Read a detached selection preference for the next eligible Session composition.
+	* @returns the enabled state and exact allowed routes.
+	*/
+	current() {
+		const current = this.source();
+		return {
+			enabled: current.enabled,
+			allowedModels: current.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 };

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

@@ -0,0 +1,81 @@
+/**
+ * Model-facing delegation through one configured `ctx.subagents` provider.
+ * Provider lifecycle controls tool registration and context-sensitive schema
+ * wording. Foreground calls always dispose the run after collection.
+ * Background policy is selected by this plugin's configuration: one-shot
+ * calls own a plain Task, while continuable calls use
+ * `ctx.subagents.startContinuable()`.
+ * @module @deepseek-ai/dsh-tool-subagent
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { AgentOptions } from '@deepseek-ai/dsh-agent';
+import type { Session } from '@deepseek-ai/dsh-session';
+export declare const name = "tool-subagent";
+export declare const inject: string[];
+/** Config: which registered provider this tool delegates to, plus child defaults. */
+export interface Config {
+    /** The `ctx.subagents` provider name to start runs on (e.g. `spawn`, `acp`). */
+    provider: string;
+    /**
+     * Model-facing tool name (default `subagent`). Each loaded instance must use
+     * a distinct name.
+     */
+    toolName?: string;
+    /**
+     * Sample the Host `subagent-model-selection` setting for each new top-level
+     * Session and inherit that decision in its child Sessions.
+     */
+    modelSelectionSettings?: boolean;
+    /**
+     * Expose `run_in_background` (default true). Disabled instances omit the
+     * parameter and reject forced background calls.
+     */
+    enableRunInBackground?: boolean;
+    /**
+     * Background execution policy (default `one-shot`). `one-shot` defaults calls
+     * to foreground; `continuable` defaults them to background, requires a provider
+     * with the `prepareContinuable` capability, and returns the durable child id.
+     * Follow-up adapters remain independently optional.
+     */
+    backgroundMode?: 'one-shot' | 'continuable';
+    /**
+     * Agent options applied to every child; omitted fields use child-loop defaults.
+     */
+    agentOptions?: AgentOptions;
+    /**
+     * Per-child persona that shadows `deployment:persona-prefix`. Requires the
+     * provider's `persona` capability; omission preserves the deployment persona.
+     */
+    persona?: string;
+    /**
+     * Tool filter applied to every child. Filtered tools disappear from its
+     * prompt and reject execution. Requires the provider's `toolFilter`
+     * capability; unknown names fail startup.
+     */
+    toolFilter?: {
+        /** Global tool names the child keeps; everything else is removed. */
+        allow?: string[];
+        /** Global tool names removed from the child. */
+        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
+     * 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.
+     */
+    maxDepth?: number | 'provider-managed';
+}
+export declare const Config: z<Config>;
+/**
+ * Install one delegation-tool composition.
+ * @param ctx - Context that owns the registrations.
+ * @param config - delegation-tool configuration.
+ * @param session - unpublished Session supplied by a direct Agent setup; omit for a standing composition.
+ */
+export declare function apply(ctx: Context, config: Config, session?: Session): void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@deepseek-ai/dsh-tool-subagent`.
+ * @module @deepseek-ai/dsh-tool-subagent/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "tool-subagent-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/vendor/subagent/types/list-models.d.ts

@@ -0,0 +1,10 @@
+/** Model-facing discovery of LLM routes available to child Agents. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ModelSelectionPolicy } from './model-selection.ts';
+/**
+ * Register `list_subagent_models` for one owning delegation-tool instance.
+ * @param ctx - Context whose tool registry owns the fixed discovery definition.
+ * @param policy - Route policy captured for this Session.
+ */
+export declare function registerListSubagentModels(ctx: Context, policy: ModelSelectionPolicy): void;
+//# sourceMappingURL=list-models.d.ts.map

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

@@ -0,0 +1,43 @@
+/** Host-owned opt-in setting for model-selectable subagent delegation. */
+import { Context, Service } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { type AllowedModelRoute } from './model-selection.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** User preference sampled when a new Session receives delegation tools. */
+        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. */
+    enabled: boolean;
+    /** 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;
+    /** Initial route list inherited when the user document does not override it. */
+    allowedModels?: 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);
+    /**
+     * 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;
+//# sourceMappingURL=model-selection-settings.d.ts.map

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

@@ -0,0 +1,48 @@
+/** Durable per-session state for the user-controlled model-selection opt-in. */
+import { z as zod } from 'zod';
+import type { Session } from '@deepseek-ai/dsh-session';
+import type SessionProjectionRegistry from '@deepseek-ai/dsh-session-projection';
+import { type AllowedModelRoute } from './model-selection.ts';
+declare module '@deepseek-ai/dsh-session/types' {
+    interface SessionEventMap {
+        /**
+         * Records that this session's delegation tool exposes child provider,
+         * model, and reasoning-effort selection. Appended before the first model
+         * request; absence means the fixed-route definition. Log-only: it carries
+         * no `surfaceOp` and never enters model history.
+         */
+        'subagent/model-selection-policy': {
+            /** Exact routes this Session may select explicitly for a child. */
+            allowedModels: AllowedModelRoute[];
+        };
+    }
+}
+declare module '@deepseek-ai/dsh-session-projection/types' {
+    interface SessionProjectionStateMap {
+        /** Exact routes authorized for child LLM selection, or null when disabled. */
+        subagentModelSelectionPolicy: AllowedModelRoute[] | null;
+    }
+}
+/** Host-only projection of the durable model-selection policy. */
+export declare const subagentModelSelectionProjectionDefinition: {
+    key: "subagentModelSelectionPolicy";
+    stateVersion: number;
+    stateSchema: zod.ZodType<AllowedModelRoute[] | null, unknown, zod.core.$ZodTypeInternals<AllowedModelRoute[] | null, unknown>>;
+    init: () => null;
+    apply: (policy: NoInfer<AllowedModelRoute[] | null>, event: import("@deepseek-ai/dsh-session").SessionEvent) => AllowedModelRoute[] | null;
+};
+/**
+ * Read the exact route list captured for a model-selectable definition.
+ * @param projections - registry that owns the policy projection.
+ * @param session - session whose durable decision is read.
+ * @returns a detached route list, or undefined for the fixed-route definition.
+ */
+export declare function subagentModelSelectionPolicy(projections: Pick<SessionProjectionRegistry, 'stateOf'>, session: Session): AllowedModelRoute[] | undefined;
+/**
+ * Append the route policy once, before its definition can reach a model request.
+ * @param projections - registry that owns the policy projection.
+ * @param session - session receiving the model-selectable definition.
+ * @param allowedModels - exact routes the definition may select explicitly.
+ */
+export declare function recordSubagentModelSelection(projections: Pick<SessionProjectionRegistry, 'stateOf'>, session: Session, allowedModels: readonly AllowedModelRoute[]): void;
+//# sourceMappingURL=model-selection-state.d.ts.map

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

@@ -0,0 +1,81 @@
+/** Child LLM route selection for the subagent tool. */
+import type { LlmRuntime } from '@deepseek-ai/dsh-llm';
+import type { AgentOptions } from '@deepseek-ai/dsh-agent';
+import z from '@deepseek-ai/schemastery';
+/** One exact child LLM route authorized by a user setting. */
+export interface AllowedModelRoute {
+    /** Registered LLM provider id. */
+    readonly provider: string;
+    /** Provider-owned exact model id. */
+    readonly model: string;
+}
+/** Schema shared by the Host setting and its deployment base. */
+export declare const AllowedModelRouteSchema: z<AllowedModelRoute>;
+/** Route-selection authority captured by one delegation definition. */
+export interface ModelSelectionPolicy {
+    /** Exact provider/model routes authorized for explicit selection. */
+    readonly routes: readonly AllowedModelRoute[];
+}
+/**
+ * Stable identity for one provider/model pair.
+ * @param route - Exact provider/model route.
+ * @returns Opaque key for equality checks.
+ */
+export declare function modelRouteKey(route: AllowedModelRoute): string;
+/**
+ * Reject malformed or duplicate route policy entries at a durable or configuration boundary.
+ * @param routes - Candidate exact routes to validate.
+ * @returns an assertion that the candidate is a validated exact-route array.
+ */
+export declare function assertAllowedModelRoutes(routes: unknown): asserts routes is readonly AllowedModelRoute[];
+/** Model-facing child LLM route fields. */
+export interface DelegationModelRequest {
+    readonly provider?: string;
+    readonly model?: string;
+    readonly reasoning_effort?: string;
+}
+/**
+ * Whether a call explicitly selects any child LLM value.
+ * @param request - Model-facing route fields from the tool call.
+ * @returns Whether at least one route or effort field is present.
+ */
+export declare function hasDelegationModelRequest(request: DelegationModelRequest): boolean;
+/**
+ * Merge model-supplied selection fields over configured child defaults.
+ * Provider and model form one route and must be supplied together. Changing
+ * that route without an effort clears the configured route-owned effort.
+ * @param parentOptions - Current parent values that supply missing child values.
+ * @param configured - Tool-instance child defaults.
+ * @param request - Model-facing route override.
+ * @param enabled - Whether this tool instance permits model-facing selection.
+ * @returns Child Agent options, preserving omission when no layer contributes one.
+ */
+export declare function requestedAgentOptions(parentOptions: AgentOptions, configured: AgentOptions | undefined, request: DelegationModelRequest, enabled: boolean): AgentOptions | undefined;
+/**
+ * Enforce a settings-owned route list at the operation that creates the child.
+ * Pure inheritance remains outside this policy because no model-facing choice
+ * occurred; any explicit route or effort field must resolve to an allowed route.
+ * @param policy - Selection authority captured for this Session.
+ * @param parentOptions - Current parent values that supply missing child values.
+ * @param requested - Effective child options after request/config merging.
+ * @param request - Model-facing selection fields from the tool call.
+ */
+export declare function assertAllowedModelSelection(policy: ModelSelectionPolicy | undefined, parentOptions: AgentOptions, requested: AgentOptions | undefined, request: DelegationModelRequest): void;
+/**
+ * Whether configured Agent options require route validation before delegation.
+ * @param options - Tool-instance child defaults.
+ * @returns Whether configured provider, model, or effort values must be resolved.
+ */
+export declare function hasConfiguredLlmSelection(options: AgentOptions | undefined): boolean;
+/**
+ * Resolve an effective child route through its live adapter before the child is
+ * created. The LLM runtime owns provider lookup, exact-model metadata, effort
+ * validation, and adapter defaults.
+ * @param llm - Live LLM runtime.
+ * @param parentOptions - Current parent values whose compatible fields the child inherits.
+ * @param requested - Per-child options after request/config merging.
+ * @param signal - Tool-call cancellation signal.
+ * @param inheritParentReasoningEffort - Whether an omitted effort may inherit from the parent route.
+ */
+export declare function preflightChildLlmRoute(llm: LlmRuntime, parentOptions: AgentOptions, requested: AgentOptions | undefined, signal: AbortSignal, inheritParentReasoningEffort?: boolean): Promise<void>;
+//# sourceMappingURL=model-selection.d.ts.map