@toddzheng024/dscode-bundle 0.4.0 → 0.6.0

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

@@ -0,0 +1,33 @@
+/**
+ * Shared driver for in-process ONE-SHOT subagent providers. The agent factory's
+ * creation transaction owns unpublished setup and rollback; after publication
+ * the returned AgentHandle is the one quiescent lifecycle owner held by the
+ * provider's caller.
+ *
+ * Continuable children never come through here: the continuation manager
+ * composes and drives them directly, so this driver owns exactly one turn with
+ * one result.
+ *
+ * @module @deepseek-ai/dsh-subagent-in-process-driver
+ */
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { ResolvedSubagentStartRequest, SubagentRun } from '@deepseek-ai/dsh-subagent';
+export { STRUCTURED_OUTPUT_TOOL, STRUCTURED_OUTPUT_INSTRUCTION, } from './structured.ts';
+/** Extra inputs the spawn and fork providers supply to the shared driver. */
+export interface InProcessRunOptions {
+    /** Completed-turn seed for fork, or undefined for a fresh spawn. */
+    readonly seed?: readonly SessionEvent[];
+}
+/**
+ * Establish and drive one in-process one-shot child. Fulfillment means the agent
+ * is already published in the registry and transfers its turn, cancellation,
+ * and disposal work through the returned run. Rejection means the agent
+ * factory's unpublished creation transaction reached quiescence without
+ * publishing a child. Every start appends its resolved descriptor inside the
+ * child's initial turn.
+ * @param request - the trusted typed start request, including its required signal.
+ * @param options - the optional fork seed.
+ * @returns a published holder-owned run.
+ */
+export declare function startInProcessRun(request: ResolvedSubagentStartRequest, options: InProcessRunOptions): Promise<SubagentRun>;
+//# sourceMappingURL=index.d.ts.map

package/vendor/subagent-driver/types/structured.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Child-scoped structured-output tool, prompt instruction, terminal guard, and authoritative
+ * result capture for in-process subagents. Each child registers its real schema on its own
+ * scope, so concurrent runs do not interact and disposal leaves no global residue. The prompt
+ * contribution is ordinary reconstructed request state.
+ *
+ * Capture commits only after the authoritative `tools/result` succeeds; PTC mode capture also
+ * waits for the enclosing `run_code` result. The terminal result marker and monotonic tool
+ * guard prevent later calls from reopening a completed structured run.
+ * @module @deepseek-ai/dsh-subagent-in-process-driver/structured
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type ObjectJsonSchema } from '@deepseek-ai/dsh-tools';
+/** The model-facing tool name a structured child must call to finish. */
+export declare const STRUCTURED_OUTPUT_TOOL = "structured_output";
+/**
+ * The instruction registered as the child's trailing scoped prompt section:
+ * the demand travels with the
+ * tool, as ordinary prompt state of exactly one agent.
+ */
+export declare const STRUCTURED_OUTPUT_INSTRUCTION: string;
+/** One structured run's live handle: read the captured value once the child settles. */
+export interface StructuredAttachment {
+    /**
+     * The captured value, once the child called the tool with valid arguments
+     * and the authoritative final tool result accepted that call.
+     * @returns the committed value, or undefined while none was accepted.
+     */
+    captured(): {
+        value: unknown;
+    } | undefined;
+}
+/**
+ * Attach the scoped capture tool, instruction, and enforcement to a child during
+ * its creation window. Child disposal removes every registration.
+ * @param childCtx - the child agent's scope context (`setup`'s argument).
+ * @param schema - the trusted, already-asserted schema subset to enforce (see
+ *   `assertObjectJsonSchema` in dsh-tools).
+ * @returns the attachment handle (read `captured()` after the child settles).
+ */
+export declare function attachStructuredRuntime(childCtx: Context, schema: ObjectJsonSchema): StructuredAttachment;
+//# sourceMappingURL=structured.d.ts.map

package/vendor/subagent-fork/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor/subagent-fork/index.js

@@ -0,0 +1,61 @@
+import z from "@deepseek-ai/schemastery";
+import { startInProcessRun } from "../subagent-driver/index.js";
+//#region lib/types/index.js
+/**
+* The in-process FORK subagent backend: registers a {@link SubagentProvider} on
+* `ctx.subagents` that runs each child as a child {@link Agent} SEEDED with a prefix of the
+* parent's session log — so the child inherits the parent's conversation context instead of
+* starting fresh. The seed ends at the last `turn/end`: the current tool-call turn is
+* unbalanced and cannot be replayed as a valid child session.
+* @module @deepseek-ai/dsh-subagent-fork-in-process
+*/
+const name = "subagent-fork-in-process";
+const inject = ["subagents"];
+const Config = z.object({ providerName: z.string().default("fork") });
+/**
+* The balanced completed-turn prefix of `parent`'s log: every event up to and including the
+* last `turn/end`. The in-flight turn is excluded; before any completed turn the child starts
+* fresh. Because live sequence numbers equal array indexes, the result remains a valid seed
+* beginning at sequence zero.
+* @param parent - the agent whose session log to slice.
+* @returns the seed events, contiguous from seq 0; empty when no turn has completed.
+*/
+function completedTurnPrefix(parent) {
+	const events = parent.session.snapshotEvents();
+	const lastEnd = events.findLast((e) => e.type === "turn/end");
+	if (lastEnd === void 0) return [];
+	return events.slice(0, lastEnd.seq + 1);
+}
+/**
+* The fork provider. Supports `depthLimit` and `outputSchema` (via the shared
+* in-process structured runtime), `agentOptions` (merged over the parent
+* route), and `toolFilter`/`persona` (scoped restrict() and a scoped shadowing
+* persona section).
+*/
+var ForkInProcessProvider = class {
+	name;
+	capabilities = {
+		agentOptions: true,
+		outputSchema: true,
+		depthLimit: true,
+		toolFilter: true,
+		persona: true
+	};
+	inheritsParentContext = true;
+	constructor(name) {
+		this.name = name;
+	}
+	start(request) {
+		const seed = completedTurnPrefix(request.parent);
+		return startInProcessRun(request, { ...seed.length > 0 ? { seed } : {} });
+	}
+	prepareContinuable(request) {
+		const seed = completedTurnPrefix(request.parent);
+		return Promise.resolve(seed.length > 0 ? { seed } : {});
+	}
+};
+function apply(ctx, config) {
+	ctx.subagents.registerProvider(new ForkInProcessProvider(config.providerName));
+}
+//#endregion
+export { Config, apply, inject, name };

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

@@ -0,0 +1,20 @@
+/**
+ * The in-process FORK subagent backend: registers a {@link SubagentProvider} on
+ * `ctx.subagents` that runs each child as a child {@link Agent} SEEDED with a prefix of the
+ * parent's session log — so the child inherits the parent's conversation context instead of
+ * starting fresh. The seed ends at the last `turn/end`: the current tool-call turn is
+ * unbalanced and cannot be replayed as a valid child session.
+ * @module @deepseek-ai/dsh-subagent-fork-in-process
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+export declare const name = "subagent-fork-in-process";
+export declare const inject: string[];
+/** Config: the registry name to register the provider under. */
+export interface Config {
+    /** Provider name on `ctx.subagents` (default `fork`). */
+    providerName: string;
+}
+export declare const Config: z<Config>;
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/vendor/subagent-spawn/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor/subagent-spawn/index.js

@@ -0,0 +1,45 @@
+import z from "@deepseek-ai/schemastery";
+import { startInProcessRun } from "../subagent-driver/index.js";
+//#region lib/types/index.js
+/**
+* The in-process SPAWN subagent backend: registers a {@link SubagentProvider} on
+* `ctx.subagents` that runs each child as a fresh child {@link Agent} on the same cordis
+* context (its own session, own system prompt, zero parent context). The cheapest transport,
+* reusing the agent factory's quiescent teardown.
+* @module @deepseek-ai/dsh-subagent-spawn-in-process
+*/
+const name = "subagent-spawn-in-process";
+const inject = ["subagents"];
+const Config = z.object({ providerName: z.string().default("spawn") });
+/**
+* The spawn provider. Supports every start-time capability: `depthLimit` (it
+* constructs the child, so it can enforce a recursion cap), `outputSchema`
+* (the scoped structured runtime), `agentOptions` (merged over the parent
+* route), and `toolFilter`/`persona` (scoped `restrict()` and a scoped
+* shadowing persona section, applied in the child's creation window).
+*/
+var SpawnInProcessProvider = class {
+	name;
+	capabilities = {
+		agentOptions: true,
+		outputSchema: true,
+		depthLimit: true,
+		toolFilter: true,
+		persona: true
+	};
+	inheritsParentContext = false;
+	constructor(name) {
+		this.name = name;
+	}
+	start(request) {
+		return startInProcessRun(request, {});
+	}
+	prepareContinuable() {
+		return Promise.resolve({});
+	}
+};
+function apply(ctx, config) {
+	ctx.subagents.registerProvider(new SpawnInProcessProvider(config.providerName));
+}
+//#endregion
+export { Config, apply, inject, name };

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

@@ -0,0 +1,19 @@
+/**
+ * The in-process SPAWN subagent backend: registers a {@link SubagentProvider} on
+ * `ctx.subagents` that runs each child as a fresh child {@link Agent} on the same cordis
+ * context (its own session, own system prompt, zero parent context). The cheapest transport,
+ * reusing the agent factory's quiescent teardown.
+ * @module @deepseek-ai/dsh-subagent-spawn-in-process
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+export declare const name = "subagent-spawn-in-process";
+export declare const inject: string[];
+/** Config: the registry name to register the provider under. */
+export interface Config {
+    /** Provider name on `ctx.subagents` (default `spawn`). */
+    providerName: string;
+}
+export declare const Config: z<Config>;
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/vendor/terminal/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.