@toddzheng024/dscode-bundle 0.4.0 → 0.5.0

package/vendor/subagent-core/types/control.js

@@ -0,0 +1,116 @@
+/**
+ * Browser-facing subagent control assembly: the catalog view sampled against
+ * the live Agent registry, one browser zone's validation, and the stable
+ * failure codes the Remote surface answers with.
+ *
+ * @module @deepseek-ai/dsh-subagent
+ */
+import { AttachmentError } from '@deepseek-ai/dsh-attachment';
+import { RemoteError } from '@deepseek-ai/dsh-typert-protocol';
+import { z } from 'zod';
+import { SubagentError } from "./error.js";
+const SESSION_ID_SCHEMA = z.string().min(1);
+const CONTROL_ID_SCHEMAS = {
+    'subagent.list': z.object({ parentSessionId: SESSION_ID_SCHEMA }),
+    'subagent.prompt': z.object({
+        parentSessionId: SESSION_ID_SCHEMA,
+        childSessionId: SESSION_ID_SCHEMA,
+        mode: z.literal('continuable'),
+        delivery: z.enum(['queue', 'steer']),
+    }),
+    'subagent.interrupt': z.object({
+        parentSessionId: SESSION_ID_SCHEMA,
+        childSessionId: SESSION_ID_SCHEMA,
+        mode: z.literal('continuable'),
+    }),
+};
+/**
+ * Apply the subagent payload checks that are stricter than generated
+ * branded-string codecs.
+ * @param method - method name carried in the failure message.
+ * @param payload - decoded control fields to validate.
+ * @throws {RemoteError} `gateway/bad-request` with the original Zod issues.
+ */
+export function validateControlRequest(method, payload) {
+    const parsed = CONTROL_ID_SCHEMAS[method].safeParse(payload);
+    if (!parsed.success) {
+        throw new RemoteError('gateway/bad-request', `invalid payload for ${method}`, { issues: parsed.error.issues });
+    }
+}
+/**
+ * Project one durable listing onto the catalog view, replacing each row's
+ * store-derived activity with the live Agent driver's status and reporting
+ * whether the exact parent Agent is live. Without an Agent registry no driver
+ * runs at all, so every row is inactive and the parent is unavailable.
+ * @param ctx - Host context that may carry the Agent registry.
+ * @param parentSessionId - the listed parent.
+ * @param entries - the durable direct-child listing.
+ * @returns the catalog view answered to one browser.
+ */
+export function catalogView(ctx, parentSessionId, entries) {
+    const agents = ctx.get('agents');
+    return {
+        entries: entries.map((entry) => entry.kind === 'child'
+            ? { ...entry, activity: agents?.get(entry.id)?.status === 'running' ? 'running' : 'inactive' }
+            : entry),
+        parentAvailable: agents?.get(parentSessionId) !== undefined,
+    };
+}
+/**
+ * Refuse one catalog read while preserving cancellation and a missing
+ * projections registry as distinct failures.
+ * @param error - the thrown value.
+ * @param signal - the caller's cancellation.
+ * @returns Never — the refusal is thrown.
+ * @throws {RemoteError} always.
+ */
+export function rejectCatalogRead(error, signal) {
+    if (isCancellation(error, signal)) {
+        throw new RemoteError('gateway/cancelled', 'subagent catalog read was cancelled', {}, { cause: error });
+    }
+    if (error instanceof SubagentError && error.code === 'SUBAGENT_CONTROL_PROJECTIONS_UNAVAILABLE') {
+        throw new RemoteError('subagent/projections-unavailable', 'subagent catalog is unavailable: this deployment does not mount the sessionProjections registry (load @deepseek-ai/dsh-session-projection)', {}, { cause: error });
+    }
+    throw new RemoteError('gateway/internal', 'subagent catalog read failed', {}, { cause: error });
+}
+/**
+ * Refuse one continuation prompt without exposing provider detail: admission
+ * failures the caller can act on keep their own code, everything else is
+ * internal.
+ * @param error - the thrown value.
+ * @param childSessionId - the addressed child.
+ * @param signal - the caller's cancellation.
+ * @returns Never — the refusal is thrown.
+ * @throws {RemoteError} always.
+ */
+export function rejectPrompt(error, childSessionId, signal) {
+    if (isCancellation(error, signal)) {
+        throw new RemoteError('gateway/cancelled', 'subagent prompt was cancelled', {}, { cause: error });
+    }
+    if (error instanceof AttachmentError) {
+        throw new RemoteError('subagent/attachment-invalid', error.message, { reason: error.code }, { cause: error });
+    }
+    if (error instanceof SubagentError) {
+        switch (error.code) {
+            case 'MODEL_DOES_NOT_SUPPORT_IMAGES':
+                throw new RemoteError('subagent/attachment-invalid', error.message, { reason: error.code }, { cause: error });
+            case 'NOT_RESUMABLE':
+                throw new RemoteError('subagent/not-resumable', 'subagent cannot be resumed', { childSessionId }, { cause: error });
+            case 'UNAUTHORIZED':
+                throw new RemoteError('subagent/unauthorized', 'subagent does not belong to this parent', { childSessionId }, { cause: error });
+            case 'DRAINING':
+            case 'ACTIVATION_CLOSING':
+            case 'CONTINUATION_UNAVAILABLE':
+            case 'PERSISTENCE_UNAVAILABLE':
+                throw new RemoteError('subagent/delivery-unavailable', 'subagent follow-up is temporarily unavailable', { childSessionId }, { cause: error });
+            // A code outside the admission vocabulary is not the caller's move to make.
+            default:
+                break;
+        }
+    }
+    throw new RemoteError('gateway/internal', 'subagent prompt failed', {}, { cause: error });
+}
+function isCancellation(error, signal) {
+    return signal.aborted || (error instanceof SubagentError && error.code === 'CANCELLED');
+}
+//# sourceMappingURL=control.js.map

package/vendor/subagent-core/types/depth.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Delegation-depth accounting: the recursion budget a parent passes to its
+ * children. Kept apart from the service so composition helpers can read it
+ * without importing the registry.
+ *
+ * @module @deepseek-ai/dsh-subagent/depth
+ */
+import type { Agent } from '@deepseek-ai/dsh-agent';
+declare module '@deepseek-ai/dsh-agent' {
+    interface AgentOptions {
+        /** Delegation depth: zero for a top-level agent and parent depth + 1 for a child. */
+        subagentDepth?: number;
+    }
+}
+/**
+ * Read an agent's delegation depth, treating absence as top-level depth zero.
+ * The persisted session header is authoritative and monotone: runtime
+ * `AgentOptions.subagentDepth` may DEEPEN the count but can never lower it —
+ * a resumed child arrives with fresh options, and counting it from zero would
+ * let it delegate as if it were top-level.
+ * @param agent - the agent whose header and options carry the depth.
+ * @returns its non-negative safe-integer depth.
+ * @throws if the runtime `AgentOptions.subagentDepth` is not a non-negative safe integer.
+ */
+export declare function delegationDepthOf(agent: Agent): number;
+/**
+ * Reject a recursion cap that cannot represent an exact delegation depth.
+ * @param maxDepth - the optional runtime value to validate.
+ */
+export declare function assertSubagentMaxDepth(maxDepth: unknown): void;
+//# sourceMappingURL=depth.d.ts.map

package/vendor/subagent-core/types/depth.js

@@ -0,0 +1,39 @@
+/**
+ * Delegation-depth accounting: the recursion budget a parent passes to its
+ * children. Kept apart from the service so composition helpers can read it
+ * without importing the registry.
+ *
+ * @module @deepseek-ai/dsh-subagent/depth
+ */
+/**
+ * Read an agent's delegation depth, treating absence as top-level depth zero.
+ * The persisted session header is authoritative and monotone: runtime
+ * `AgentOptions.subagentDepth` may DEEPEN the count but can never lower it —
+ * a resumed child arrives with fresh options, and counting it from zero would
+ * let it delegate as if it were top-level.
+ * @param agent - the agent whose header and options carry the depth.
+ * @returns its non-negative safe-integer depth.
+ * @throws if the runtime `AgentOptions.subagentDepth` is not a non-negative safe integer.
+ */
+export function delegationDepthOf(agent) {
+    const runtime = agent.options.subagentDepth;
+    if (runtime !== undefined && (!Number.isSafeInteger(runtime) || runtime < 0 || Object.is(runtime, -0))) {
+        throw new TypeError('agent subagentDepth must be a non-negative safe integer');
+    }
+    // The header value was validated at the session boundary (creation and
+    // persistence load both construct through the store).
+    return Math.max(agent.session.header.delegationDepth ?? 0, runtime ?? 0);
+}
+/**
+ * Reject a recursion cap that cannot represent an exact delegation depth.
+ * @param maxDepth - the optional runtime value to validate.
+ */
+export function assertSubagentMaxDepth(maxDepth) {
+    if (maxDepth !== undefined && (typeof maxDepth !== 'number'
+        || !Number.isSafeInteger(maxDepth)
+        || maxDepth < 0
+        || Object.is(maxDepth, -0))) {
+        throw new TypeError('subagent maxDepth must be a non-negative safe integer');
+    }
+}
+//# sourceMappingURL=depth.js.map

package/vendor/subagent-core/types/descriptor.d.ts

@@ -0,0 +1,144 @@
+/**
+ * The durable subagent-child descriptor: the versioned, model-hidden
+ * `subagent/descriptor` session event that identifies every session-backed
+ * subagent and records whether it is one-shot or continuable. Continuable
+ * descriptors additionally preserve the declared composition required for
+ * cold resume. Providers append it turn-enclosed in the child's initial turn.
+ *
+ * The descriptor deliberately snapshots explicit fields rather than the
+ * merge-extensible `AgentOptions` object: an unrelated extension value cannot
+ * make continuation fail merely because it is not JSON, and later composition
+ * inputs require a deliberate {@link SUBAGENT_DESCRIPTOR_VERSION} change. It
+ * omits `subagentDepth` — cold resume trusts the persisted header's
+ * `delegationDepth` as the monotone floor — and `outputSchema`, which belongs
+ * to one activation's result contract rather than durable child composition.
+ * Per-activation knobs such as `maxTokens` are omitted for the same reason as
+ * `outputSchema`: they budget one activation. Cold resume requires the exact
+ * live parent for authorization but reconstructs child options only from the
+ * durable descriptor, so it neither restores the prior budget nor inherits
+ * the parent's current one; the resumed route's defaults apply instead.
+ *
+ * @module @deepseek-ai/dsh-subagent/descriptor
+ */
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { ReasoningEffortId } from '@deepseek-ai/dsh-llm';
+import type { ToolRestriction } from '@deepseek-ai/dsh-tools';
+declare module '@deepseek-ai/dsh-session/types' {
+    interface SessionEventMap {
+        /**
+         * Durable identity and lifecycle mode of a session-backed subagent child,
+         * appended once by the establishing provider inside the child's initial
+         * turn, before its first request. Continuable records also carry their
+         * resumable composition. Log-only: it carries no `surfaceOp`, never enters
+         * model history, and survives compaction.
+         */
+        'subagent/descriptor': SubagentDescriptorData;
+    }
+}
+/**
+ * The current descriptor format version, stamped into every appended
+ * `subagent/descriptor` event and required verbatim by {@link foldSubagentDescriptor}.
+ * Supporting another composition input is a deliberate version change, never
+ * an implicit extra field.
+ */
+export declare const SUBAGENT_DESCRIPTOR_VERSION = 3;
+/** Fields shared by every supported `subagent/descriptor` payload. */
+interface SubagentDescriptorBase {
+    /** Descriptor format version ({@link SUBAGENT_DESCRIPTOR_VERSION}). */
+    readonly version: number;
+    /** Whether the child is a terminal one-shot run or a resumable conversation. */
+    readonly mode: 'one-shot' | 'continuable';
+    /** The `ctx.subagents` provider name that established the child. */
+    readonly provider: string;
+}
+/** A session-backed subagent that cannot be cold-resumed after its run. */
+export interface OneShotSubagentDescriptorData extends SubagentDescriptorBase {
+    readonly mode: 'one-shot';
+    /**
+     * The initial delegation's short `description`, kept as the child's durable
+     * creation label so enumeration can identify the conversation without
+     * replaying parent tool results or exposing the child prompt.
+     */
+    readonly label?: string;
+}
+/** A session-backed subagent whose declared composition supports cold resume. */
+export interface ContinuableSubagentDescriptorData extends SubagentDescriptorBase {
+    readonly mode: 'continuable';
+    /** The initial delegation's short `description`, used for durable enumeration. */
+    readonly label: string;
+    /** Resolved child `agentOptions.provider`, when one was declared. */
+    readonly agentProvider?: string;
+    /** Resolved child `agentOptions.model`, when one was declared. */
+    readonly agentModel?: string;
+    /** Resolved child `agentOptions.reasoningEffort`, when one was declared. */
+    readonly agentReasoningEffort?: ReasoningEffortId;
+    /** Per-child persona that shadows the deployment persona on resume. */
+    readonly persona?: string;
+    /** Child tool scoping reapplied on resume. */
+    readonly toolFilter?: ToolRestriction;
+}
+/** The supported durable subagent identity and optional continuation composition. */
+export type SubagentDescriptorData = OneShotSubagentDescriptorData | ContinuableSubagentDescriptorData;
+/** Fields shared by descriptor snapshot inputs. */
+interface SubagentDescriptorInputBase {
+    /** Whether the child is a terminal one-shot run or a resumable conversation. */
+    readonly mode: 'one-shot' | 'continuable';
+    /** The `ctx.subagents` provider name that will establish the child. */
+    readonly provider: string;
+}
+/** Input for a one-shot child's durable identity. */
+export interface OneShotSubagentDescriptorInput extends SubagentDescriptorInputBase {
+    readonly mode: 'one-shot';
+    /** Optional initial delegation `description` used as the durable creation label. */
+    readonly label?: string;
+}
+/** Input for a continuable child's durable identity and resumable composition. */
+export interface ContinuableSubagentDescriptorInput extends SubagentDescriptorInputBase {
+    readonly mode: 'continuable';
+    /** Initial delegation `description` used for durable enumeration. */
+    readonly label: string;
+    /** Requested child `agentOptions.provider`. */
+    readonly agentProvider?: string;
+    /** Requested child `agentOptions.model`. */
+    readonly agentModel?: string;
+    /** Requested child `agentOptions.reasoningEffort`. */
+    readonly agentReasoningEffort?: ReasoningEffortId;
+    /** Requested per-child persona. */
+    readonly persona?: string;
+    /** Requested child tool scoping. */
+    readonly toolFilter?: ToolRestriction;
+}
+/** Inputs {@link snapshotSubagentDescriptor} validates and detaches. */
+export type SubagentDescriptorInput = OneShotSubagentDescriptorInput | ContinuableSubagentDescriptorInput;
+/**
+ * Validate and detach descriptor inputs into the durable payload, before any
+ * Task or provider work begins — the same detached lossless-JSON boundary the
+ * session log itself enforces, applied early so a synchronous validation
+ * failure rejects the tool call without creating a Task.
+ * @param input - the caller-collected composition fields.
+ * @returns the versioned, detached descriptor payload.
+ * @throws when a field is not losslessly JSON-serializable.
+ */
+export declare function snapshotSubagentDescriptor(input: OneShotSubagentDescriptorInput): OneShotSubagentDescriptorData;
+/**
+ * Validate and detach a continuable descriptor input.
+ * @param input - the caller-collected continuable composition fields.
+ * @returns the versioned, detached continuable descriptor payload.
+ * @throws when a field is not losslessly JSON-serializable.
+ */
+export declare function snapshotSubagentDescriptor(input: ContinuableSubagentDescriptorInput): ContinuableSubagentDescriptorData;
+/**
+ * Fold a persisted child log to its supported descriptor. The first
+ * `subagent/descriptor` event is authoritative — the establishing provider
+ * appends exactly one, so a later same-type event cannot rewrite the declared
+ * composition.
+ * @param events - the loaded child session events.
+ * @returns the descriptor, or `undefined` when the log has none or its
+ *   version is not {@link SUBAGENT_DESCRIPTOR_VERSION} (the child cannot be
+ *   classified by this runtime).
+ * @throws when a current-version persisted payload does not match its complete
+ *   declared schema.
+ */
+export declare function foldSubagentDescriptor(events: readonly SessionEvent[]): SubagentDescriptorData | undefined;
+export {};
+//# sourceMappingURL=descriptor.d.ts.map

package/vendor/subagent-core/types/descriptor.js

@@ -0,0 +1,193 @@
+/**
+ * The durable subagent-child descriptor: the versioned, model-hidden
+ * `subagent/descriptor` session event that identifies every session-backed
+ * subagent and records whether it is one-shot or continuable. Continuable
+ * descriptors additionally preserve the declared composition required for
+ * cold resume. Providers append it turn-enclosed in the child's initial turn.
+ *
+ * The descriptor deliberately snapshots explicit fields rather than the
+ * merge-extensible `AgentOptions` object: an unrelated extension value cannot
+ * make continuation fail merely because it is not JSON, and later composition
+ * inputs require a deliberate {@link SUBAGENT_DESCRIPTOR_VERSION} change. It
+ * omits `subagentDepth` — cold resume trusts the persisted header's
+ * `delegationDepth` as the monotone floor — and `outputSchema`, which belongs
+ * to one activation's result contract rather than durable child composition.
+ * Per-activation knobs such as `maxTokens` are omitted for the same reason as
+ * `outputSchema`: they budget one activation. Cold resume requires the exact
+ * live parent for authorization but reconstructs child options only from the
+ * durable descriptor, so it neither restores the prior budget nor inherits
+ * the parent's current one; the resumed route's defaults apply instead.
+ *
+ * @module @deepseek-ai/dsh-subagent/descriptor
+ */
+import { snapshotJsonValue } from '@deepseek-ai/dsh-util-values';
+/**
+ * The current descriptor format version, stamped into every appended
+ * `subagent/descriptor` event and required verbatim by {@link foldSubagentDescriptor}.
+ * Supporting another composition input is a deliberate version change, never
+ * an implicit extra field.
+ */
+export const SUBAGENT_DESCRIPTOR_VERSION = 3;
+const DESCRIPTOR_BASE_KEYS = [
+    'version',
+    'mode',
+    'provider',
+    'label',
+];
+const ONE_SHOT_DESCRIPTOR_KEYS = new Set(DESCRIPTOR_BASE_KEYS);
+const CONTINUABLE_DESCRIPTOR_KEYS = new Set([
+    ...DESCRIPTOR_BASE_KEYS,
+    'agentProvider',
+    'agentModel',
+    'agentReasoningEffort',
+    'persona',
+    'toolFilter',
+]);
+const TOOL_FILTER_KEYS = new Set(['allow', 'deny']);
+/** Whether a persisted JSON value is an object record. */
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Reject fields outside one versioned record's declared schema. */
+function assertKnownKeys(value, keys, path) {
+    const unknown = Object.keys(value).find(key => !keys.has(key));
+    if (unknown !== undefined) {
+        throw new Error(`persisted subagent descriptor ${path} has unknown field "${unknown}"`);
+    }
+}
+/** Read one optional string field from a persisted descriptor record. */
+function optionalString(value, key) {
+    if (!Object.hasOwn(value, key))
+        return undefined;
+    const field = value[key];
+    if (typeof field !== 'string') {
+        throw new Error(`persisted subagent descriptor ${key} must be a string`);
+    }
+    return field;
+}
+/** Read one optional string-array field from a persisted tool restriction. */
+function optionalStringArray(value, key) {
+    if (!Object.hasOwn(value, key))
+        return undefined;
+    const field = value[key];
+    if (!Array.isArray(field)) {
+        throw new Error(`persisted subagent descriptor toolFilter.${key} must be an array of strings`);
+    }
+    const items = field;
+    if (items.some(item => typeof item !== 'string')) {
+        throw new Error(`persisted subagent descriptor toolFilter.${key} must be an array of strings`);
+    }
+    return items;
+}
+/** Validate and reconstruct a persisted tool restriction. */
+function parseToolFilter(value) {
+    if (!isRecord(value)) {
+        throw new Error('persisted subagent descriptor toolFilter must be an object');
+    }
+    assertKnownKeys(value, TOOL_FILTER_KEYS, 'toolFilter');
+    const allow = optionalStringArray(value, 'allow');
+    const deny = optionalStringArray(value, 'deny');
+    if (allow === undefined && deny === undefined) {
+        throw new Error('persisted subagent descriptor toolFilter must declare allow and/or deny');
+    }
+    return {
+        ...allow !== undefined ? { allow } : {},
+        ...deny !== undefined ? { deny } : {},
+    };
+}
+/** Validate one persisted descriptor payload for the current runtime. */
+function parseSubagentDescriptor(value) {
+    if (!isRecord(value)) {
+        throw new Error('persisted subagent descriptor payload must be an object');
+    }
+    const version = value['version'];
+    if (typeof version !== 'number') {
+        throw new Error('persisted subagent descriptor version must be a number');
+    }
+    if (version !== SUBAGENT_DESCRIPTOR_VERSION)
+        return undefined;
+    const mode = value['mode'];
+    if (mode !== 'one-shot' && mode !== 'continuable') {
+        throw new Error('persisted subagent descriptor mode must be "one-shot" or "continuable"');
+    }
+    assertKnownKeys(value, mode === 'one-shot' ? ONE_SHOT_DESCRIPTOR_KEYS : CONTINUABLE_DESCRIPTOR_KEYS, 'payload');
+    const provider = value['provider'];
+    if (typeof provider !== 'string') {
+        throw new Error('persisted subagent descriptor provider must be a string');
+    }
+    if (mode === 'one-shot') {
+        const label = optionalString(value, 'label');
+        return {
+            version: SUBAGENT_DESCRIPTOR_VERSION,
+            mode,
+            provider,
+            ...label !== undefined ? { label } : {},
+        };
+    }
+    const label = value['label'];
+    if (typeof label !== 'string') {
+        throw new Error('persisted subagent descriptor label must be a string');
+    }
+    const agentProvider = optionalString(value, 'agentProvider');
+    const agentModel = optionalString(value, 'agentModel');
+    const agentReasoningEffort = optionalString(value, 'agentReasoningEffort');
+    const persona = optionalString(value, 'persona');
+    const toolFilter = Object.hasOwn(value, 'toolFilter')
+        ? parseToolFilter(value['toolFilter'])
+        : undefined;
+    return {
+        version: SUBAGENT_DESCRIPTOR_VERSION,
+        mode,
+        provider,
+        label,
+        ...agentProvider !== undefined ? { agentProvider } : {},
+        ...agentModel !== undefined ? { agentModel } : {},
+        ...agentReasoningEffort !== undefined ? { agentReasoningEffort } : {},
+        ...persona !== undefined ? { persona } : {},
+        ...toolFilter !== undefined ? { toolFilter } : {},
+    };
+}
+export function snapshotSubagentDescriptor(input) {
+    const candidate = input.mode === 'one-shot'
+        ? {
+            version: SUBAGENT_DESCRIPTOR_VERSION,
+            mode: input.mode,
+            provider: input.provider,
+            ...input.label !== undefined ? { label: input.label } : {},
+        }
+        : {
+            version: SUBAGENT_DESCRIPTOR_VERSION,
+            mode: input.mode,
+            provider: input.provider,
+            label: input.label,
+            ...input.agentProvider !== undefined ? { agentProvider: input.agentProvider } : {},
+            ...input.agentModel !== undefined ? { agentModel: input.agentModel } : {},
+            ...input.agentReasoningEffort !== undefined ? { agentReasoningEffort: input.agentReasoningEffort } : {},
+            ...input.persona !== undefined ? { persona: input.persona } : {},
+            ...input.toolFilter !== undefined ? { toolFilter: input.toolFilter } : {},
+        };
+    const snapshot = snapshotJsonValue(candidate);
+    if (snapshot === undefined) {
+        throw new Error('subagent descriptor is not losslessly JSON-serializable');
+    }
+    return snapshot;
+}
+/**
+ * Fold a persisted child log to its supported descriptor. The first
+ * `subagent/descriptor` event is authoritative — the establishing provider
+ * appends exactly one, so a later same-type event cannot rewrite the declared
+ * composition.
+ * @param events - the loaded child session events.
+ * @returns the descriptor, or `undefined` when the log has none or its
+ *   version is not {@link SUBAGENT_DESCRIPTOR_VERSION} (the child cannot be
+ *   classified by this runtime).
+ * @throws when a current-version persisted payload does not match its complete
+ *   declared schema.
+ */
+export function foldSubagentDescriptor(events) {
+    const event = events.find((candidate) => candidate.type === 'subagent/descriptor');
+    if (event === undefined)
+        return undefined;
+    return parseSubagentDescriptor(event.data);
+}
+//# sourceMappingURL=descriptor.js.map

package/vendor/subagent-core/types/error.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Typed failures shared by subagent service and provider operations.
+ *
+ * @module @deepseek-ai/dsh-subagent
+ */
+import { HarnessError } from '@deepseek-ai/dsh-llm';
+/** Typed failure for the subagent seam. */
+export declare class SubagentError extends HarnessError {
+    constructor(message: string, code: string, options?: ErrorOptions);
+}
+//# sourceMappingURL=error.d.ts.map

package/vendor/subagent-core/types/error.js

@@ -0,0 +1,14 @@
+/**
+ * Typed failures shared by subagent service and provider operations.
+ *
+ * @module @deepseek-ai/dsh-subagent
+ */
+import { HarnessError } from '@deepseek-ai/dsh-llm';
+/** Typed failure for the subagent seam. */
+export class SubagentError extends HarnessError {
+    constructor(message, code, options) {
+        super(message, code, options);
+        this.name = 'SubagentError';
+    }
+}
+//# sourceMappingURL=error.js.map

package/vendor/subagent-core/types/inbox.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Activation-local admission around one continuable subagent's Agent inbox.
+ *
+ * @module @deepseek-ai/dsh-subagent/inbox
+ */
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { UserMessage } from '@deepseek-ai/dsh-session';
+import type { SubagentPromptRequest } from './control-types.ts';
+/** One Agent inbox destination, as the wire request selects it. */
+export type SubagentDelivery = SubagentPromptRequest['delivery'];
+/** Delegate Queue and Steer to one live Agent until its Activation starts closing. */
+export declare class SubagentInbox {
+    private readonly agent;
+    private closingPromise;
+    /**
+     * Wrap one live continuable Agent.
+     * @param agent - the Agent whose inbox receives accepted deliveries.
+     */
+    constructor(agent: Agent);
+    /**
+     * Read the Activation's close transaction.
+     * @returns the memoized transaction, or `undefined` while delivery remains open.
+     */
+    get closing(): Promise<void> | undefined;
+    /**
+     * Read whether the underlying Agent still has accepted work to claim.
+     * @returns whether either Agent inbox destination is non-empty.
+     */
+    get hasPending(): boolean;
+    /**
+     * Submit through the Agent only while its Activation remains resident.
+     * @param message - the accepted input to submit.
+     * @param delivery - whether to queue a distinct turn or steer the nearest step.
+     */
+    deliver(message: UserMessage, delivery: SubagentDelivery): void;
+    /**
+     * Close delivery synchronously and share one asynchronous release.
+     * @param release - the one release operation to start after closing admission.
+     * @returns the memoized release transaction.
+     */
+    close(release: () => Promise<void>): Promise<void>;
+}
+//# sourceMappingURL=inbox.d.ts.map

package/vendor/subagent-core/types/inbox.js

@@ -0,0 +1,61 @@
+/**
+ * Activation-local admission around one continuable subagent's Agent inbox.
+ *
+ * @module @deepseek-ai/dsh-subagent/inbox
+ */
+import { SubagentError } from "./error.js";
+/** Delegate Queue and Steer to one live Agent until its Activation starts closing. */
+export class SubagentInbox {
+    agent;
+    closingPromise;
+    /**
+     * Wrap one live continuable Agent.
+     * @param agent - the Agent whose inbox receives accepted deliveries.
+     */
+    constructor(agent) {
+        this.agent = agent;
+    }
+    /**
+     * Read the Activation's close transaction.
+     * @returns the memoized transaction, or `undefined` while delivery remains open.
+     */
+    get closing() {
+        return this.closingPromise;
+    }
+    /**
+     * Read whether the underlying Agent still has accepted work to claim.
+     * @returns whether either Agent inbox destination is non-empty.
+     */
+    get hasPending() {
+        return this.agent.inbox.nextTurn.length > 0 || this.agent.inbox.nextStep.length > 0;
+    }
+    /**
+     * Submit through the Agent only while its Activation remains resident.
+     * @param message - the accepted input to submit.
+     * @param delivery - whether to queue a distinct turn or steer the nearest step.
+     */
+    deliver(message, delivery) {
+        if (this.closingPromise !== undefined) {
+            throw new SubagentError(`subagent "${this.agent.id}" activation is being disposed; the message was not accepted`, 'ACTIVATION_CLOSING');
+        }
+        if (delivery === 'steer')
+            this.agent.steer(message);
+        else
+            this.agent.followup(message);
+    }
+    /**
+     * Close delivery synchronously and share one asynchronous release.
+     * @param release - the one release operation to start after closing admission.
+     * @returns the memoized release transaction.
+     */
+    close(release) {
+        const existing = this.closingPromise;
+        if (existing !== undefined)
+            return existing;
+        const completion = Promise.withResolvers();
+        this.closingPromise = completion.promise;
+        void release().then(completion.resolve, completion.reject);
+        return completion.promise;
+    }
+}
+//# sourceMappingURL=inbox.js.map