dsh-agent-plugins-market 0.9.2 → 0.10.0

package/lib/packages/market-catalog/src/scanning/archive.js

@@ -141,8 +141,39 @@ export async function archiveInstall(url, dest, options = {}) {
  * within fflate's synchronous push recursion overflows the stack); the
  * chunked feed halts at the next slice.
  */
+/**
+ * Entry count declared by a zip's end-of-central-directory record.
+ *
+ * The stream cannot always reach its per-entry guard: fflate parses a
+ * whole-archive central directory recursively, and a zip with tens of thousands
+ * of tiny members overflows the stack inside one `push()` before `onfile` can
+ * count them. Reading the declared count first refuses such an archive before
+ * any decompression, and the streaming guard still covers what the record
+ * understates.
+ * @param bytes - the complete archive.
+ * @returns the declared total entry count, or undefined when unreadable or zip64.
+ */
+function zipDeclaredEntryCount(bytes) {
+    const EOCD_SIGNATURE = 0x06_05_4b_50;
+    const EOCD_MIN_BYTES = 22;
+    const MAX_COMMENT_BYTES = 0xffff;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const lowest = Math.max(0, bytes.byteLength - EOCD_MIN_BYTES - MAX_COMMENT_BYTES);
+    for (let offset = bytes.byteLength - EOCD_MIN_BYTES; offset >= lowest; offset -= 1) {
+        if (view.getUint32(offset, true) !== EOCD_SIGNATURE)
+            continue;
+        const declared = view.getUint16(offset + 10, true);
+        // 0xffff defers to zip64, whose real count lives in a different record.
+        return declared === 0xffff ? undefined : declared;
+    }
+    return undefined;
+}
 async function extractZip(archiveFile, dest) {
     const compressed = await readFile(archiveFile);
+    const declared = zipDeclaredEntryCount(compressed);
+    if (declared !== undefined && declared > ARCHIVE_MAX_ENTRIES) {
+        throw new Error(`archive exceeds the ${ARCHIVE_MAX_ENTRIES} entry limit`);
+    }
     let totalBytes = 0;
     let entryCount = 0;
     let failure;

package/lib/packages/market-catalog/src/scanning/validate.js

@@ -33,8 +33,25 @@ function schemasDirectory() {
     let directory = dirname(fileURLToPath(import.meta.url));
     while (true) {
         const manifest = join(directory, 'package.json');
-        if (existsSync(manifest) && JSON.parse(readFileSync(manifest, 'utf8')).name === 'dsh-agent-plugins-market')
+        if (!existsSync(manifest)) {
+            const parent = dirname(directory);
+            if (parent === directory)
+                throw new Error('dsh-agent-plugins-market package root is unavailable');
+            directory = parent;
+            continue;
+        }
+        const name = JSON.parse(readFileSync(manifest, 'utf8')).name;
+        // The workspace package and the packed artifact expose the library at the
+        // same two relative spots: beside the catalog package, or under the
+        // packages/ path preserved by the npm files entry.
+        if (name === '@dsh-market/catalog')
             return join(directory, 'schemas');
+        if (name === 'dsh-agent-plugins-market')
+            return join(directory, 'packages/market-catalog/schemas');
+        const parentDir = dirname(directory);
+        if (parentDir === directory)
+            throw new Error('dsh-agent-plugins-market package root is unavailable');
+        directory = parentDir;
         const parent = dirname(directory);
         if (parent === directory)
             throw new Error('dsh-agent-plugins-market package root is unavailable');

package/lib/packages/market-mcp/src/runtime/mcp/bridge/connection.js

@@ -83,9 +83,11 @@ export function resolveReconnectPolicy(config, path) {
  * @param policy - Resolved reconnect policy from {@link resolveReconnectPolicy}.
  * @param credentials - The composition's credential store, when mounted; OAuth
  *   state persists only when it is.
+ * @param opener - Browser opener for the OAuth human leg; the platform browser
+ *   by default.
  * @returns Handle with a `ready` promise for startup-await and a `dispose` for teardown.
  */
-export function startConnection(host, config, policy, credentials) {
+export function startConnection(host, config, policy, credentials, opener) {
     const label = `mcp-client(${config.serverName})`;
     const opts = {
         registrationFailure: 'contain',
@@ -258,9 +260,33 @@ export function startConnection(host, config, policy, credentials) {
             clientClosed = undefined;
             host.logger.error(`${label}: failed generation did not close within ${GENERATION_CLOSE_TIMEOUT_MS}ms — reconnect stopped to avoid overlapping server processes; reload the plugin or restart the Host to retry`);
         }
+        /**
+         * Retire the generation that raised the `401` and re-establish in place.
+         *
+         * The SDK aborts that generation's handshake the moment the human leg
+         * returns: the initialize that triggered the authorization is gone, so the
+         * saved tokens only ever reach the server on a fresh call. Running that
+         * call here — instead of scheduling a backoff retry — lets `ready` report
+         * the mount's real outcome rather than a failure the caller has to count on
+         * a retry to repair after the user already approved.
+         */
+        async function reestablishAfterAuthorization() {
+            attemptSettled = true;
+            client = undefined;
+            clientClosed = undefined;
+            try {
+                await generation.close();
+            }
+            catch {
+                /* transport already gone */
+            }
+            if (disposed)
+                return;
+            await connectGeneration(false);
+        }
         const { transport, oauthProvider } = createTransport(config, credentials, (message) => {
             host.logger.info(message);
-        });
+        }, opener);
         try {
             await generation.connect(transport, { timeout: opts.startupTimeoutMs });
             if (hasClosed()) {
@@ -288,32 +314,25 @@ export function startConnection(host, config, policy, credentials) {
                 attemptSettled = true;
                 if (!isCurrent(generation))
                     return;
-                // The leg failed, or the transport closed while it ran: no generation
-                // is left to finish establishing.
-                if (hasClosed() || !legSettled) {
-                    generationDown(generation);
-                    return;
-                }
-                // The exchange succeeded inside this generation: finish establishing
-                // it (tool sync + connected bookkeeping) instead of respawning.
-                try {
-                    await enqueueSync(generation, startup ? startupOpts : opts);
-                }
-                catch (syncError) {
-                    if (isCurrent(generation))
-                        host.logger.warn(`${label}: tool sync after authorization failed: ${String(syncError)}`);
-                    await teardownFailedAttempt();
-                    return;
-                }
-                if (hasClosed()) {
+                // A failed leg leaves nothing to establish. A successful one always
+                // needs a fresh generation: the SDK closes this one as soon as the
+                // initialize that raised the `401` fails, whether that was the request
+                // timeout the human approval outlived or the redirect the leg returns.
+                if (!legSettled) {
                     generationDown(generation);
                     return;
                 }
+                await reestablishAfterAuthorization();
+                return;
+            }
+            // A leg that finished inside this attempt leaves no pending promise: the
+            // SDK aborts the connect that raised the `401` as soon as the browser leg
+            // returns. The tokens are saved either way, so no handshake on this
+            // generation can carry them.
+            if (oauthProvider?.lastBrowserLegOutcome === true) {
                 if (!isCurrent(generation))
                     return;
-                connectedAt = Date.now();
-                if (failedAttempts > 0)
-                    host.logger.info(`${label}: authorized and re-synced tools (attempt ${failedAttempts}/${policy.maxAttempts})`);
+                await reestablishAfterAuthorization();
                 return;
             }
             await teardownFailedAttempt();

package/lib/packages/market-mcp/src/runtime/mcp/bridge/oauth.js

@@ -132,6 +132,14 @@ export class LoopbackOAuthClientProvider {
     expectedState;
     /** Resolves `true` when the leg saved tokens, `false` when it failed; undefined while no leg is open. */
     browserLegSettled;
+    /**
+     * Outcome of the most recently finished browser leg, `true` when the code
+     * exchange saved tokens. The pending-leg promise disappears when the leg
+     * settles, and a leg that finishes inside the `connect` that raised the
+     * `401` leaves nothing pending for a supervisor to observe — this field is
+     * how the supervisor still learns that the authorization succeeded.
+     */
+    lastLegOutcome;
     callbackServer;
     callbackTimer;
     boundPort;
@@ -149,7 +157,10 @@ export class LoopbackOAuthClientProvider {
     get redirectUrl() {
         // RFC 8252 §7.3: loopback redirects may vary the port per request, so the
         // bound port is filled in when the listener starts and registration
-        // metadata always reflects the current attempt's URL.
+        // metadata always reflects the current attempt's URL. The value must keep
+        // reading as the bound port until the code exchange finishes: the token
+        // request repeats this exact URL (RFC 6749 §4.1.3), and an authorization
+        // server that compares it with the authorization request rejects port `0`.
         return `http://127.0.0.1:${this.boundPort ?? this.storage.callbackPort ?? 0}/callback`;
     }
     get clientMetadata() {
@@ -214,6 +225,12 @@ export class LoopbackOAuthClientProvider {
             return;
         }
         finally {
+            // The loopback URL stays published until here. Clearing the port when
+            // the callback arrives would hand the token endpoint `redirect_uri =
+            // http://127.0.0.1:0/callback` while the authorization request carried
+            // the real port, which RFC 6749 §4.1.3 forbids and servers enforce.
+            this.boundPort = undefined;
+            this.lastLegOutcome = succeeded;
             this.browserLegSettled?.resolve(succeeded);
             this.browserLegSettled = undefined;
         }
@@ -232,6 +249,14 @@ export class LoopbackOAuthClientProvider {
     get browserLeg() {
         return this.browserLegSettled?.promise;
     }
+    /**
+     * The most recent finished leg's outcome; `undefined` until one finishes.
+     * The supervisor reads it after a failed attempt: a leg that settled inside
+     * the attempt itself leaves no pending {@link browserLeg} behind.
+     */
+    get lastBrowserLegOutcome() {
+        return this.lastLegOutcome;
+    }
     /**
      * Register the transport generation whose `finishAuth` completes the flow.
      * The transport calls `redirectToAuthorization` during `connect`; binding
@@ -420,7 +445,9 @@ export class LoopbackOAuthClientProvider {
         }
         this.clearCallbackTimer();
         this.callbackServer = undefined;
-        this.boundPort = undefined;
+        // The bound port deliberately survives this callback: the code exchange
+        // runs a moment later and must present the same `redirect_uri` the
+        // authorization request used. An aborted leg clears it in resetCallback.
         this.expectedState = undefined;
         if (oauthError !== null) {
             const description = redactErrorMessage(url.searchParams.get('error_description') ?? '');

package/lib/packages/market-mcp/src/runtime/mcp/bridge/transport.js

@@ -33,11 +33,11 @@ function hasStaticAuthorization(headers) {
  * when the config opts out or the headers already carry a static
  * Authorization.
  */
-function buildOAuthProvider(config, credentials, log) {
+function buildOAuthProvider(config, credentials, log, opener) {
     const auth = config.auth;
     if (auth?.enabled === false || hasStaticAuthorization(config.headers))
         return undefined;
-    return new LoopbackOAuthClientProvider(config.serverName, auth?.storage ?? {}, auth?.scope, log, credentials);
+    return new LoopbackOAuthClientProvider(config.serverName, auth?.storage ?? {}, auth?.scope, log, credentials, opener);
 }
 /**
  * Create an MCP transport from the resolved bridge config.
@@ -54,11 +54,14 @@ function buildOAuthProvider(config, credentials, log) {
  * @param credentials - The composition's credential store, when mounted; OAuth
  *   state persists only when it is.
  * @param log - Diagnostic sink for the human leg of the flow.
+ * @param opener - Browser opener for the OAuth human leg; the platform browser
+ *   by default. A caller that owns the human leg (a host surface, or a test
+ *   driving the authorization endpoint directly) passes its own.
  * @returns The transport plus its OAuth provider, when active — the
  *   supervisor queries the provider to hold the generation open while a
  *   browser leg is pending.
  */
-export function createTransport(config, credentials, log = () => { }) {
+export function createTransport(config, credentials, log = () => { }, opener) {
     switch (config.transport) {
         case 'stdio':
             return {
@@ -71,7 +74,7 @@ export function createTransport(config, credentials, log = () => { }) {
                 oauthProvider: undefined
             };
         case 'streamable-http': {
-            const oauthProvider = buildOAuthProvider(config, credentials, log);
+            const oauthProvider = buildOAuthProvider(config, credentials, log, opener);
             // The MCP SDK's StreamableHTTPClientTransport has optional callback
             // properties typed without `| undefined` (exactOptionalPropertyTypes
             // mismatch with the Transport interface); the SDK constructed the
@@ -86,7 +89,7 @@ export function createTransport(config, credentials, log = () => { }) {
             return { transport, oauthProvider };
         }
         case 'sse': {
-            const oauthProvider = buildOAuthProvider(config, credentials, log);
+            const oauthProvider = buildOAuthProvider(config, credentials, log, opener);
             // The legacy SSE transport negotiates a separate endpoint POST channel.
             // The SDK applies `requestInit.headers` to both the stream request and
             // every endpoint POST (its `_commonHeaders` merge), so no separate

package/lib/packages/market-runtime/src/runtime/agents/agent-role-router.js

@@ -6,6 +6,7 @@ import { isAbsentPath } from '../../application/fs-probe.js';
 import { namedAgentRoles } from './agent-role-names.js';
 import { expandPluginPaths } from '../../../../market-catalog/src/index.js';
 import { parseAgentRole } from '../../application/agent-roles.js';
+import { startContinuableChild } from './subagent-seam.js';
 export { parseAgentRole };
 export const AGENT_ROLE_TOOL_NAME = 'subagent_role';
 /**
@@ -217,7 +218,7 @@ export async function executeAgentRole(host, listRoles, agentName, prompt, paren
         ...(agentOptions === undefined ? {} : { agentOptions })
     };
     if (mode === 'continuable') {
-        const started = await host.subagents.startContinuable({ provider: 'spawn', label: agentName, request, signal });
+        const started = await startContinuableChild(host.subagents, { provider: 'spawn', label: agentName, request, signal });
         return { kind: 'continuable', subagentId: started.childId };
     }
     const run = await host.subagents.start('spawn', { ...request, signal });

package/lib/packages/market-runtime/src/runtime/agents/subagent-seam.js

@@ -0,0 +1,29 @@
+/**
+ * Start one continuable child on whichever start member the host exposes.
+ * @param seam - the live `ctx.subagents` service.
+ * @param input - provider, label, delegation request, and cancellation.
+ * @returns the child identity the host reserved.
+ * @throws when the host exposes neither start member.
+ */
+export function startContinuableChild(seam, input) {
+    if (typeof seam.startContinuable === 'function')
+        return seam.startContinuable(input);
+    if (typeof seam.startActivation === 'function')
+        return seam.startActivation({ ...input, delivery: 'parent' });
+    return Promise.reject(new Error('the host subagent service exposes neither startContinuable nor startActivation'));
+}
+/**
+ * Release selected resident continuable children on whichever drain member the
+ * host exposes.
+ * @param seam - the live `ctx.subagents` service.
+ * @param parent - exact live direct parent authorizing the release.
+ * @param childIds - durable direct-child ids to release when resident.
+ * @throws when the host exposes neither drain member.
+ */
+export function drainContinuableChildIds(seam, parent, childIds) {
+    if (typeof seam.drainContinuableChildren === 'function')
+        return seam.drainContinuableChildren(parent, childIds);
+    if (typeof seam.drainChildren === 'function')
+        return seam.drainChildren(parent, childIds);
+    return Promise.reject(new Error('the host subagent service exposes neither drainContinuableChildren nor drainChildren'));
+}

package/lib/packages/market-runtime/src/runtime/agents/teammate-role-runtime.js

@@ -4,6 +4,7 @@ import { installModelSelection } from '@deepseek-ai/dsh-agent';
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { foldSubagentDescriptor } from '@deepseek-ai/dsh-subagent';
 import { z } from 'zod';
+import { drainContinuableChildIds } from './subagent-seam.js';
 const PROVIDER = 'market-role-team';
 export const TEAM_ROLE_SOURCE = 'teammate-role-binding';
 const routeSchema = z.object({ provider: z.string().min(1), model: z.string().min(1), reasoningEffort: z.string().min(1).optional() }).strict();
@@ -79,10 +80,15 @@ export class TeammateRoleRuntime {
         this.ctx = ctx;
         this.teams = ctx.get('agentTeams');
         this.subagents = ctx.get('subagents');
+        // The 0.2.1-alpha.4 host removed `toolFilter` and `persona` from the capability
+        // record and added `agentPreset`; the 0.2.0-rc.2 baseline types require the first
+        // two. One variable satisfies both shapes because the host reads only the flags
+        // it knows, while an object literal would fail the newer excess-property check.
+        const capabilities = { agentOptions: false, agentPreset: false, outputSchema: false, depthLimit: false, toolFilter: false, persona: false };
         this.registrations.push(this.subagents.registerProvider({
             name: PROVIDER,
             inheritsParentContext: false,
-            capabilities: { agentOptions: false, outputSchema: false, depthLimit: false, toolFilter: false, persona: false },
+            capabilities,
             start: () => Promise.reject(new Error('role teammates require Team continuation')),
             prepareContinuable: request => {
                 const pending = this.pending.getStore();
@@ -227,7 +233,7 @@ export class TeammateRoleRuntime {
                 byParent.set(parent, [...(byParent.get(parent) ?? []), agent.id]);
         }
         try {
-            await Promise.all([...byParent].map(([parent, ids]) => this.subagents.drainContinuableChildren(parent, ids)));
+            await Promise.all([...byParent].map(([parent, ids]) => drainContinuableChildIds(this.subagents, parent, ids)));
         }
         finally {
             for (const off of this.registrations.splice(0).reverse())

package/lib/packages/market-runtime/src/runtime/host/scoped-contributors.js

@@ -98,6 +98,10 @@ export class ScopedExtensionContributors {
             scope.systemPrompt.section({
                 name: 'agent-plugins:instructions',
                 order: 500,
+                // Suite-authored Markdown is literal text, never a template: the host
+                // interpolates by default and refuses an unknown `{{name}}`, so a suite
+                // that quotes `{{cwd}}` would fail prompt assembly before any request.
+                interpolate: false,
                 text: () => mount.active
                     ? mount.instructions
                         .filter(row => this.ports.allows(agent, row.parent) && this.ports.allows(agent, row.id))

package/lib/packages/market-runtime/src/runtime/surfaces/project-runtime.js

@@ -28,7 +28,10 @@ suiteAllowed) {
     return mountProjectSurface(ctx, catalog, 'systemPrompt', (scope, agent) => {
         let text = '';
         const host = scope;
-        const dispose = host.systemPrompt.section({ name: 'agent-plugins:instructions', order: 500, text: () => text });
+        // Suite-authored Markdown is literal text, never a template: the host
+        // interpolates by default and refuses an unknown `{{name}}`, so a suite that
+        // quotes `{{cwd}}` would fail prompt assembly before any model request.
+        const dispose = host.systemPrompt.section({ name: 'agent-plugins:instructions', order: 500, interpolate: false, text: () => text });
         return {
             async reconcile(projectSuites) {
                 const projectDir = agent.session.header.cwd;

package/lib/types/packages/market-mcp/src/runtime/mcp/bridge/connection.d.ts

@@ -20,6 +20,7 @@
  *
  * @module runtime/mcp-client/connection
  */
+import type { BrowserOpener } from './oauth.js';
 import type { ToolHost } from './tools.js';
 import type { Config } from '../../../application/mcp/mcp-bridge-config.js';
 /** Automatic reconnect policy for one MCP server connection. */
@@ -69,6 +70,8 @@ export interface ConnectionHandle {
  * @param policy - Resolved reconnect policy from {@link resolveReconnectPolicy}.
  * @param credentials - The composition's credential store, when mounted; OAuth
  *   state persists only when it is.
+ * @param opener - Browser opener for the OAuth human leg; the platform browser
+ *   by default.
  * @returns Handle with a `ready` promise for startup-await and a `dispose` for teardown.
  */
-export declare function startConnection(host: ToolHost, config: Config, policy: ResolvedReconnectPolicy, credentials?: unknown): ConnectionHandle;
+export declare function startConnection(host: ToolHost, config: Config, policy: ResolvedReconnectPolicy, credentials?: unknown, opener?: BrowserOpener): ConnectionHandle;

package/lib/types/packages/market-mcp/src/runtime/mcp/bridge/oauth.d.ts

@@ -67,6 +67,14 @@ export declare class LoopbackOAuthClientProvider implements OAuthClientProvider
     private expectedState;
     /** Resolves `true` when the leg saved tokens, `false` when it failed; undefined while no leg is open. */
     private browserLegSettled;
+    /**
+     * Outcome of the most recently finished browser leg, `true` when the code
+     * exchange saved tokens. The pending-leg promise disappears when the leg
+     * settles, and a leg that finishes inside the `connect` that raised the
+     * `401` leaves nothing pending for a supervisor to observe — this field is
+     * how the supervisor still learns that the authorization succeeded.
+     */
+    private lastLegOutcome;
     private callbackServer;
     private callbackTimer;
     private boundPort;
@@ -98,6 +106,12 @@ export declare class LoopbackOAuthClientProvider implements OAuthClientProvider
      * settles.
      */
     get browserLeg(): Promise<boolean> | undefined;
+    /**
+     * The most recent finished leg's outcome; `undefined` until one finishes.
+     * The supervisor reads it after a failed attempt: a leg that settled inside
+     * the attempt itself leaves no pending {@link browserLeg} behind.
+     */
+    get lastBrowserLegOutcome(): boolean | undefined;
     /**
      * Register the transport generation whose `finishAuth` completes the flow.
      * The transport calls `redirectToAuthorization` during `connect`; binding

package/lib/types/packages/market-mcp/src/runtime/mcp/bridge/transport.d.ts

@@ -10,6 +10,7 @@
  */
 import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
 import { LoopbackOAuthClientProvider } from './oauth.js';
+import type { BrowserOpener } from './oauth.js';
 import type { Config } from '../../../application/mcp/mcp-bridge-config.js';
 /**
  * Create an MCP transport from the resolved bridge config.
@@ -26,11 +27,14 @@ import type { Config } from '../../../application/mcp/mcp-bridge-config.js';
  * @param credentials - The composition's credential store, when mounted; OAuth
  *   state persists only when it is.
  * @param log - Diagnostic sink for the human leg of the flow.
+ * @param opener - Browser opener for the OAuth human leg; the platform browser
+ *   by default. A caller that owns the human leg (a host surface, or a test
+ *   driving the authorization endpoint directly) passes its own.
  * @returns The transport plus its OAuth provider, when active — the
  *   supervisor queries the provider to hold the generation open while a
  *   browser leg is pending.
  */
-export declare function createTransport(config: Config, credentials?: unknown, log?: (message: string) => void): {
+export declare function createTransport(config: Config, credentials?: unknown, log?: (message: string) => void, opener?: BrowserOpener): {
     transport: Transport;
     oauthProvider: LoopbackOAuthClientProvider | undefined;
 };

package/lib/types/packages/market-runtime/src/runtime/agents/agent-role-router.d.ts

@@ -1,6 +1,7 @@
 import type { Context } from '@deepseek-ai/cordis';
 import { type SubagentCatalogEntry } from './subagent-catalog.js';
 import { parseAgentRole, type AgentRoleEntry, type AgentRolePolicy } from '../../application/agent-roles.js';
+import { type ContinuableSubagentSeam } from './subagent-seam.js';
 export { parseAgentRole };
 export type { AgentRoleEntry, AgentRolePolicy };
 /** A declaration that has been through the call-name pass, so it answers exactly one callable name. */
@@ -40,16 +41,7 @@ export interface AgentRoleHost {
             reasoningEffort?: string;
         }, signal?: AbortSignal): Promise<unknown>;
     };
-    subagents: {
-        startContinuable(spec: {
-            provider: string;
-            label: string;
-            request: AgentRoleDelegation;
-            signal: AbortSignal;
-        }): Promise<{
-            childId: string;
-            messageId: string;
-        }>;
+    subagents: ContinuableSubagentSeam & {
         /** One-shot foreground run: the host settles it and hands back the child's output. */
         start(provider: string, request: AgentRoleRunRequest): Promise<AgentRoleRun>;
     };

package/lib/types/packages/market-runtime/src/runtime/agents/subagent-seam.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Cross-release access to the host subagent seam.
+ *
+ * The host renamed its continuable-child operations in 0.2.1-alpha.4:
+ * `startContinuable` became `startActivation`, and `drainContinuableChildren`
+ * became `drainChildren`. The plugin pins the 0.2.0-rc.2 baseline, so the
+ * published types name the old members; this module resolves whichever member
+ * the live service exposes and keeps one source tree working on both releases.
+ *
+ * Every member is optional and every call is guarded, per the plugin standard's
+ * rule for a host capability the declared types do not carry. A host exposing
+ * neither name is unsupported, and the refusal names both members rather than
+ * failing with a property access on undefined.
+ *
+ * @module runtime/agents/subagent-seam
+ */
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { SessionId } from '@deepseek-ai/dsh-session';
+/** The child identity both releases return once the child accepts its first prompt. */
+export interface ContinuableChildStart {
+    /** The host reserves a branded session id; the plugin only forwards the value. */
+    readonly childId: string;
+    readonly messageId?: string;
+}
+/** One continuable start as this plugin issues it, in the older release's spelling. */
+export interface ContinuableStartInput {
+    readonly provider: string;
+    readonly label: string;
+    readonly request: unknown;
+    readonly signal: AbortSignal;
+}
+/**
+ * The host subagent members this plugin drives, across both release lines.
+ *
+ * The 0.2.1-alpha.4 activation additionally requires `delivery`; the older
+ * continuable start always notified the parent, so the adapter supplies that
+ * value explicitly.
+ */
+export interface ContinuableSubagentSeam {
+    startContinuable?(spec: ContinuableStartInput): Promise<ContinuableChildStart>;
+    startActivation?(spec: ContinuableStartInput & {
+        readonly delivery?: 'parent' | 'caller';
+    }): Promise<ContinuableChildStart>;
+    drainContinuableChildren?(parent: Agent, childIds: readonly SessionId[]): Promise<void>;
+    drainChildren?(parent: Agent, childIds: readonly SessionId[]): Promise<void>;
+}
+/**
+ * Start one continuable child on whichever start member the host exposes.
+ * @param seam - the live `ctx.subagents` service.
+ * @param input - provider, label, delegation request, and cancellation.
+ * @returns the child identity the host reserved.
+ * @throws when the host exposes neither start member.
+ */
+export declare function startContinuableChild(seam: ContinuableSubagentSeam, input: ContinuableStartInput): Promise<ContinuableChildStart>;
+/**
+ * Release selected resident continuable children on whichever drain member the
+ * host exposes.
+ * @param seam - the live `ctx.subagents` service.
+ * @param parent - exact live direct parent authorizing the release.
+ * @param childIds - durable direct-child ids to release when resident.
+ * @throws when the host exposes neither drain member.
+ */
+export declare function drainContinuableChildIds(seam: ContinuableSubagentSeam, parent: Agent, childIds: readonly SessionId[]): Promise<void>;