@deepseek-ai/dsh-subagent 0.1.1-rc.2 → 0.1.2-alpha.3

package/lib/types/continuation.js

@@ -20,9 +20,61 @@
  *
  * @module @deepseek-ai/dsh-subagent
  */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { randomUUID } from 'node:crypto';
-import { boundContextSummary, createUserMessage, errorChain } from '@deepseek-ai/dsh-llm';
-import { SessionId } from '@deepseek-ai/dsh-session';
+import { brandString } from '@deepseek-ai/dsh-brand';
+import { ReasoningEffortId, boundContextSummary, contentHasImage, createUserMessage, errorChain } from '@deepseek-ai/dsh-llm';
 import { foldSubagentDescriptor, snapshotSubagentDescriptor } from "./descriptor.js";
 import { appendDelegatedPolicyOverrides, applyChildComposition, captureDelegatedPolicyOverrides, childSessionMeta, resolveChildAgentOptions, resolveChildDepth, } from "./child-agent.js";
 import { assertSubagentMaxDepth } from "./depth.js";
@@ -156,19 +208,22 @@ export class SubagentContinuationManager {
         this.assertAdmitting(parent);
         const persistence = this.requirePersistence();
         assertSubagentMaxDepth(request.maxDepth);
-        const childId = spec.childId ?? SessionId(randomUUID());
+        const childId = spec.childId ?? brandString(randomUUID());
         this.assertChildIdAvailable(childId);
         const childDepth = resolveChildDepth(parent, request.maxDepth);
         // Snapshot before any await: invalid descriptor JSON rejects the call
         // before a child exists, and the detached value is what reaches the log.
-        const agentProvider = request.agentOptions?.provider ?? parent.options.provider;
-        const agentModel = request.agentOptions?.model ?? parent.options.model;
+        const agentOptions = resolveChildAgentOptions(parent, request.agentOptions, childDepth);
+        const agentProvider = agentOptions.provider;
+        const agentModel = agentOptions.model;
+        const agentReasoningEffort = agentOptions.reasoningEffort;
         const descriptor = snapshotSubagentDescriptor({
             mode: 'continuable',
             provider: spec.provider,
             label: spec.label,
             ...agentProvider !== undefined ? { agentProvider } : {},
             ...agentModel !== undefined ? { agentModel } : {},
+            ...agentReasoningEffort !== undefined ? { agentReasoningEffort } : {},
             ...request.persona !== undefined ? { persona: request.persona } : {},
             ...request.toolFilter !== undefined ? { toolFilter: request.toolFilter } : {},
         });
@@ -202,7 +257,7 @@ export class SubagentContinuationManager {
                 provider: spec.provider,
                 parent,
                 create: { seed, meta: childSessionMeta(parent, childDepth, lineageSeedLength), delegatedPolicies },
-                agentOptions: resolveChildAgentOptions(parent, request.agentOptions, childDepth),
+                agentOptions,
                 composition: { persona: request.persona, toolFilter: request.toolFilter },
                 signal: spec.signal,
             });
@@ -242,12 +297,25 @@ export class SubagentContinuationManager {
                     return this.coldResume(parent, childId, content, options);
                 // A delivery that arrives after the disposal transaction began must not
                 // reach a handle being torn down; wait for release, then cold-resume.
+                const disposal = activation.disposal;
                 /* v8 ignore next 3 -- the send-versus-dispose cutoff: reaching this arm needs a
                  * delivery to observe the transaction inside the same critical section that opened it,
                  * which no test can schedule deterministically. The behavior is covered end-to-end by
                  * "cold-resumes a delivery that lost the race with final disposal". */
-                if (activation.disposal !== undefined) {
-                    return activation.disposal.then(() => undefined, () => undefined);
+                if (disposal !== undefined) {
+                    return disposal.then(() => undefined, () => undefined);
+                }
+                // Text-only delivery stays await-free, so the disposal-cutoff check
+                // above and the submit share one critical window. The image path
+                // awaits a capability read, so it re-checks the cutoff afterwards; a
+                // disposal that began during the read is waited out and retried like
+                // one observed on entry.
+                if (contentHasImage(content)) {
+                    await this.assertImageCapable(activation.handle.agent, options.signal);
+                    if (activation.disposal !== undefined) {
+                        await Promise.allSettled([activation.disposal]);
+                        return undefined;
+                    }
                 }
                 return this.submitAdmitted(activation, content, options.source, parent, options.signal);
             });
@@ -610,56 +678,71 @@ export class SubagentContinuationManager {
         return 'settled';
     }
     /**
-     * Cold-resume a persisted child: inspect and authorize its Session, fold the
+     * Cold-resume a persisted child: retain and authorize its prepared Session, fold the
      * generic descriptor, create the Activation through `ctx.agents.resume()`,
      * and submit the waiting turn. This never dispatches through a subagent
      * provider — the persisted Session already holds the initial prefix and the
      * descriptor is the whole reconstruction input.
      */
     async coldResume(parent, childId, content, options) {
-        const persistence = this.requirePersistence();
-        let loaded;
+        const env_1 = { stack: [], error: void 0, hasError: false };
         try {
-            loaded = await persistence.inspect(childId, options.signal);
-        }
-        catch (error) {
-            options.signal.throwIfAborted();
-            throw new SubagentError(`subagent "${childId}" is unavailable`, 'NOT_RESUMABLE', { cause: error });
-        }
-        options.signal.throwIfAborted();
-        this.assertAdmitting(parent);
-        // Authorize the persisted header before folding: only the durable child's
-        // exact live direct parent may continue it.
-        this.authorizeLineage(parent, childId, loaded.meta.parentSession);
-        // Fold only the child's own suffix: a fork seed replays the parent's log,
-        // which may carry an ANCESTOR's descriptor when the parent is itself a
-        // continuable child.
-        const descriptor = foldSubagentDescriptor(loaded.events.slice(loaded.meta.seedLength ?? 0));
-        if (descriptor === undefined || descriptor.mode !== 'continuable') {
-            throw new SubagentError(`subagent "${childId}" has no supported continuation state and cannot be resumed; `
-                + 'do not retry send_message with this id', 'NOT_RESUMABLE');
+            const query = this.requireSessionQuery();
+            let observation;
+            try {
+                observation = await query.observeSession(childId, {
+                    signal: options.signal,
+                });
+            }
+            catch (error) {
+                options.signal.throwIfAborted();
+                throw new SubagentError(`subagent "${childId}" is unavailable`, 'NOT_RESUMABLE', { cause: error });
+            }
+            const source = __addDisposableResource(env_1, observation, false);
+            this.assertAdmitting(parent);
+            // Authorize the persisted header before folding: only the durable child's
+            // exact live direct parent may continue it.
+            this.authorizeLineage(parent, childId, source.header.parentSession);
+            // Fold only the child's own suffix: a fork seed replays the parent's log,
+            // which may carry an ANCESTOR's descriptor when the parent is itself a
+            // continuable child.
+            const descriptor = foldSubagentDescriptor(source.events.slice(source.header.seedLength ?? 0));
+            if (descriptor === undefined || descriptor.mode !== 'continuable') {
+                throw new SubagentError(`subagent "${childId}" has no supported continuation state and cannot be resumed; `
+                    + 'do not retry send_message with this id', 'NOT_RESUMABLE');
+            }
+            let activation;
+            try {
+                activation = await this.materialize({
+                    childId,
+                    provider: descriptor.provider,
+                    parent,
+                    agentOptions: {
+                        ...descriptor.agentProvider !== undefined ? { provider: descriptor.agentProvider } : {},
+                        ...descriptor.agentModel !== undefined ? { model: descriptor.agentModel } : {},
+                        ...descriptor.agentReasoningEffort !== undefined
+                            ? { reasoningEffort: ReasoningEffortId(descriptor.agentReasoningEffort) }
+                            : {},
+                    },
+                    composition: { persona: descriptor.persona, toolFilter: descriptor.toolFilter },
+                    signal: options.signal,
+                });
+            }
+            catch (error) {
+                options.signal.throwIfAborted();
+                if (error instanceof SubagentError)
+                    throw error;
+                throw new SubagentError(`subagent "${childId}" is unavailable`, 'NOT_RESUMABLE', { cause: error });
+            }
+            return await this.submitMaterialized(activation, content, options.source, parent, options.signal);
         }
-        let activation;
-        try {
-            activation = await this.materialize({
-                childId,
-                provider: descriptor.provider,
-                parent,
-                agentOptions: {
-                    ...descriptor.agentProvider !== undefined ? { provider: descriptor.agentProvider } : {},
-                    ...descriptor.agentModel !== undefined ? { model: descriptor.agentModel } : {},
-                },
-                composition: { persona: descriptor.persona, toolFilter: descriptor.toolFilter },
-                signal: options.signal,
-            });
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
         }
-        catch (error) {
-            options.signal.throwIfAborted();
-            if (error instanceof SubagentError)
-                throw error;
-            throw new SubagentError(`subagent "${childId}" is unavailable`, 'NOT_RESUMABLE', { cause: error });
+        finally {
+            __disposeResources(env_1);
         }
-        return this.submitMaterialized(activation, content, options.source, parent, options.signal);
     }
     /**
      * Submit to a freshly materialized Activation or roll it back completely.
@@ -672,6 +755,15 @@ export class SubagentContinuationManager {
      */
     async submitMaterialized(activation, content, source, parent, signal) {
         try {
+            if (contentHasImage(content)) {
+                // The capability read awaits with the activation already published, so
+                // the disposal cutoff is re-checked before the submit; a drain that
+                // began during the read turns into a clean closing rejection.
+                await this.assertImageCapable(activation.handle.agent, signal);
+                if (activation.disposal !== undefined) {
+                    throw new SubagentError(`subagent "${activation.childId}" is closing`, 'ACTIVATION_CLOSING');
+                }
+            }
             return this.submitAdmitted(activation, content, source, parent, signal);
         }
         catch (error) {
@@ -681,6 +773,32 @@ export class SubagentContinuationManager {
             throw error;
         }
     }
+    /**
+     * Refuse image content addressed to a child whose model accepts text only.
+     * Callers guard with `contentHasImage`, so text-only delivery never awaits.
+     * The check runs inside the per-child delivery lock, before the message
+     * exists, so a rejection leaves no partial user message. When the child's
+     * route is not fixed by its options (a request-waterfall listener owns it)
+     * or no LLM registry is composed, delivery proceeds and the LLM layer's
+     * text-only projection replaces each image with its stable placeholder.
+     * @param agent - the live or freshly materialized child agent.
+     * @param signal - caller cancellation bounding the model-info read.
+     * @throws {SubagentError} `MODEL_DOES_NOT_SUPPORT_IMAGES` when the child's resolved model declines image input.
+     */
+    async assertImageCapable(agent, signal) {
+        const { provider, model } = agent.options;
+        if (provider === undefined || model === undefined)
+            return;
+        const llm = this.ctx.get('llm');
+        /* v8 ignore next -- a deployment without the LLM registry serves no model
+         * to refuse against; delivery then defers to the text-only projection. */
+        if (llm === undefined)
+            return;
+        const info = await llm.resolveModelInfo(provider, model, signal);
+        if (info.inputModalities !== undefined && !info.inputModalities.includes('image')) {
+            throw new SubagentError(`Model "${model}" does not support image input.`, 'MODEL_DOES_NOT_SUPPORT_IMAGES');
+        }
+    }
     /**
      * Create or resume the child Agent through the private activation-owner
      * scope, install the handle in a fresh Activation, and register ownership on
@@ -1146,6 +1264,14 @@ export class SubagentContinuationManager {
         }
         return persistence;
     }
+    /** Resolve the Session query service used for cold child observations. */
+    requireSessionQuery() {
+        const query = this.ctx.get('sessionQuery');
+        if (query === undefined) {
+            throw new SubagentError('continuable subagents require session query (load @deepseek-ai/dsh-session-query)', 'CONTINUATION_UNAVAILABLE');
+        }
+        return query;
+    }
 }
 export default SubagentContinuationManager;
 //# sourceMappingURL=continuation.js.map

package/lib/types/control-types.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Client-safe subagent catalog and control vocabulary: the durable direct-child
+ * row both the listing and the browser catalog answer with, plus the
+ * browser-facing control surface's prompt, receipts, and failures.
+ *
+ * @module @deepseek-ai/dsh-subagent/control-types
+ */
+import type { PromptContentPart } from '@deepseek-ai/dsh-attachment/types';
+import type { Branded } from '@deepseek-ai/dsh-brand';
+import type { MessageId } from '@deepseek-ai/dsh-llm/brand';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+/**
+ * Client-minted identity of one browser prompt, persisted on the exact accepted
+ * message. It carries the Session Controller's `session-request-id` brand so a
+ * subagent prompt and an ordinary Session prompt share one identity
+ * vocabulary; that package depends on this one, so the brand is spelled here
+ * rather than imported.
+ */
+export type SubagentPromptRequestId = Branded<'session-request-id'>;
+/**
+ * One durable direct-child row, ordered by header `createdAt` with ties broken
+ * on id. Only a candidate whose durable header has `origin: 'subagent'` is
+ * interpreted. A served `subagent` projection value produces a `child`; a
+ * settled candidate whose fold served no identity produces a `diagnostic`; a
+ * running candidate without one is omitted — its descriptor may not be
+ * appended yet (the creation window). Diagnostics relay the projection fold's
+ * outcome or a failed read, never a per-child event scan, and never expose
+ * model-hidden descriptor content.
+ */
+export type SubagentListEntry = {
+    readonly kind: 'child';
+    /** The durable child session id, stable across Activations. */
+    readonly id: SessionId;
+    /**
+     * Whether the child is live at the moment its reader sampled it: the
+     * durable listing reads the Session store (`running` means the logical
+     * record is resident, `inactive` that it exists only in persistence),
+     * while the browser catalog re-samples the child's Agent driver. Neither
+     * encodes a durable outcome, and a continuable child may still reject
+     * delivery as an ownership conflict.
+     */
+    readonly activity: 'running' | 'inactive';
+    /** Whether a direct descendant has durable `origin: 'subagent'`. */
+    readonly hasChildren: boolean;
+} & ({
+    /** A terminal one-shot child. */
+    readonly mode: 'one-shot';
+    /** Optional durable creation label from the child's descriptor. */
+    readonly label?: string;
+} | {
+    /** A resumable conversation. */
+    readonly mode: 'continuable';
+    /** Durable creation label from the child's descriptor. */
+    readonly label: string;
+}) | {
+    readonly kind: 'diagnostic';
+    /** The candidate's session id. */
+    readonly id: SessionId;
+    /**
+     * Why the candidate has no `child` row: `corrupt` for a settled candidate
+     * whose projection fold served no identity (a missing, malformed, or
+     * unrecognized-version descriptor — deliberately undistinguished), and
+     * for any candidate whose log makes a registered unit's fold or schema
+     * throw (deterministic data damage, contained per child); `unavailable`
+     * when the candidate's Session observation was absent or transiently
+     * unreadable (retried on the next listing). `unsupported` is never produced; it remains in the
+     * union for consumers that route on it.
+     */
+    readonly reason: 'corrupt' | 'unsupported' | 'unavailable';
+};
+/** Complete direct-child catalog plus the delivery-time parent availability hint. */
+export interface SubagentCatalog {
+    readonly entries: readonly SubagentListEntry[];
+    readonly parentAvailable: boolean;
+}
+/** Durable parent/child address that selects subagent transport in the client. */
+export type SubagentAddress = {
+    readonly parentSessionId: SessionId;
+    readonly childSessionId: SessionId;
+} & ({
+    readonly mode: 'one-shot';
+} | {
+    readonly mode: 'continuable';
+});
+/** One human message addressed to a continuable direct child. */
+export interface SubagentPromptRequest {
+    /** Identity persisted on the accepted message, minted before the call. */
+    readonly requestId: SubagentPromptRequestId;
+    readonly parentSessionId: SessionId;
+    readonly childSessionId: SessionId;
+    /** Required discriminator retained from the browser control address. */
+    readonly mode: 'continuable';
+    /**
+     * Browser prompt parts delivered as the child's user message. The Host
+     * admits and persists image parts before delivery, so the wire never
+     * carries a durable attachment reference the caller could fabricate.
+     */
+    readonly content: readonly PromptContentPart[];
+    /** Optional browser zone sampled for this exact human prompt. */
+    readonly clientTimeZone?: string;
+}
+/** Inbox identity returned once the continuation accepts one human message. */
+export interface SubagentPromptReceipt {
+    readonly messageId: MessageId;
+}
+/** Uniform acknowledgement that one interrupt request was admitted. */
+export interface SubagentInterruptReceipt {
+    readonly accepted: true;
+}
+/**
+ * Failure details the control surface answers with. Catalog reads, prompts,
+ * and interrupts share this vocabulary with the Client Remote result.
+ */
+declare module '@deepseek-ai/dsh-typert-protocol' {
+    interface RemoteErrorDetailsMap {
+        /** A browser-supplied zone is neither UTC nor a canonical IANA name. */
+        'subagent/invalid-time-zone': {
+            readonly value: string;
+        };
+        /** No live Agent carries the addressed parent session. */
+        'subagent/parent-unavailable': {
+            readonly parentSessionId: SessionId;
+        };
+        /** The addressed child cannot take a continuation. */
+        'subagent/not-resumable': {
+            readonly childSessionId: SessionId;
+        };
+        /** The claimed parent does not own the addressed child. */
+        'subagent/unauthorized': {
+            readonly childSessionId: SessionId;
+        };
+        /** Image admission or model image-capability refusal. */
+        'subagent/attachment-invalid': {
+            readonly reason: string;
+        };
+        /** The child exists but its inbox cannot admit the message now. */
+        'subagent/delivery-unavailable': {
+            readonly childSessionId: SessionId;
+        };
+        /** The deployment mounts no session-projection registry. */
+        'subagent/projections-unavailable': {};
+    }
+}
+//# sourceMappingURL=control-types.d.ts.map

package/lib/types/control-types.js

@@ -0,0 +1,9 @@
+/**
+ * Client-safe subagent catalog and control vocabulary: the durable direct-child
+ * row both the listing and the browser catalog answer with, plus the
+ * browser-facing control surface's prompt, receipts, and failures.
+ *
+ * @module @deepseek-ai/dsh-subagent/control-types
+ */
+export {};
+//# sourceMappingURL=control-types.js.map

package/lib/types/control.d.ts

@@ -0,0 +1,67 @@
+/**
+ * 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 type { Context } from '@deepseek-ai/cordis';
+import type { SessionId } from '@deepseek-ai/dsh-session';
+import { z } from 'zod';
+import type { SubagentCatalog, SubagentListEntry } from './control-types.ts';
+declare const CONTROL_ID_SCHEMAS: {
+    readonly 'subagent.list': z.ZodObject<{
+        parentSessionId: z.ZodString;
+    }, z.core.$strip>;
+    readonly 'subagent.prompt': z.ZodObject<{
+        parentSessionId: z.ZodString;
+        childSessionId: z.ZodString;
+        mode: z.ZodLiteral<"continuable">;
+    }, z.core.$strip>;
+    readonly 'subagent.interrupt': z.ZodObject<{
+        parentSessionId: z.ZodString;
+        childSessionId: z.ZodString;
+        mode: z.ZodLiteral<"continuable">;
+    }, z.core.$strip>;
+};
+/**
+ * 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 declare function validateControlRequest(method: keyof typeof CONTROL_ID_SCHEMAS, payload: unknown): void;
+/**
+ * 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 declare function catalogView(ctx: Context, parentSessionId: SessionId, entries: readonly SubagentListEntry[]): SubagentCatalog;
+/**
+ * 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 declare function rejectCatalogRead(error: unknown, signal: AbortSignal): never;
+/**
+ * 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 declare function rejectPrompt(error: unknown, childSessionId: SessionId, signal: AbortSignal): never;
+export {};
+//# sourceMappingURL=control.d.ts.map

package/lib/types/control.js

@@ -0,0 +1,115 @@
+/**
+ * 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'),
+    }),
+    '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