@morlay/dsh-subagent 0.0.10 → 0.0.11-alpha.0

package/src/vendor/dsh-subagent/continuation-messages.ts

@@ -4,19 +4,19 @@
  * @module @deepseek-ai/dsh-subagent/continuation-messages
  */
 
-import type { Agent } from "@deepseek-ai/dsh-agent";
-import { boundContextSummary, createUserMessage } from "@deepseek-ai/dsh-llm";
-import type { ContentBlock } from "@deepseek-ai/dsh-llm";
-import type { SessionId } from "@deepseek-ai/dsh-session";
-import type { SubagentResult } from "./types.ts";
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import { boundContextSummary, createUserMessage } from '@deepseek-ai/dsh-llm'
+import type { ContentBlock } from '@deepseek-ai/dsh-llm'
+import type { SessionId } from '@deepseek-ai/dsh-session'
+import type { SubagentResult } from './types.ts'
 
 /** Durable attribution for one model-authored message between Agents. */
 export interface AgentMessageSource {
-  readonly kind: "agent-message";
+  readonly kind: 'agent-message'
   /** A message another agent addressed to this one (`relay` context form). */
-  readonly form: "relay";
+  readonly form: 'relay'
   /** Session id of the Agent whose tool call produced the message. */
-  readonly senderSessionId: SessionId;
+  readonly senderSessionId: SessionId
 }
 
 /**
@@ -27,29 +27,29 @@ export interface AgentMessageSource {
  * transcript that merged them would credit the child with words it never wrote.
  */
 export interface SubagentSettledMessageSource {
-  readonly kind: "subagent-settled";
+  readonly kind: 'subagent-settled'
   /** A runtime account shown without expanding the row (`notice` context form). */
-  readonly form: "notice";
+  readonly form: 'notice'
   /** One-line account of how the child ended. */
-  readonly summary: string;
+  readonly summary: string
   /** Session id of the child that settled. */
-  readonly senderSessionId: SessionId;
+  readonly senderSessionId: SessionId
 }
 
-declare module "@deepseek-ai/dsh-llm" {
+declare module '@deepseek-ai/dsh-llm' {
   interface MessageSourceMap {
-    "agent-message": AgentMessageSource;
-    "subagent-settled": SubagentSettledMessageSource;
+    'agent-message': AgentMessageSource
+    'subagent-settled': SubagentSettledMessageSource
   }
 }
 
 /** Build durable attribution for one adjacent-Agent message. */
 function agentMessageSource(sender: Agent): AgentMessageSource {
   return {
-    kind: "agent-message",
-    form: "relay",
+    kind: 'agent-message',
+    form: 'relay',
     senderSessionId: sender.id,
-  };
+  }
 }
 
 /**
@@ -63,9 +63,12 @@ export function createAgentMessage(
   content: ContentBlock[],
 ): ReturnType<typeof createUserMessage> {
   return createUserMessage({
-    content: [{ type: "text" as const, text: `Agent ${sender.id} sent a message: ` }, ...content],
+    content: [
+      { type: 'text' as const, text: `Agent ${sender.id} sent a message: ` },
+      ...content,
+    ],
     source: agentMessageSource(sender),
-  });
+  })
 }
 
 /**
@@ -78,19 +81,18 @@ export function withContinuableReturnGuidance(
   parentId: SessionId,
   prompt: ContentBlock[],
 ): ContentBlock[] {
-  const encodedParentId = JSON.stringify(parentId);
+  const encodedParentId = JSON.stringify(parentId)
   return [
     ...prompt,
     {
-      type: "text",
-      text:
-        `Your parent agent id is ${encodedParentId}. Before you finish, send your result to that agent with ` +
-        `send_message({ agent_id: ${encodedParentId}, message: "<self-contained result>" }). The parent shares ` +
-        "your workspace but does not automatically receive your transcript, tool output, or reasoning. Send " +
-        "earlier messages as well when a finding changes what the parent should do next; sending a message " +
-        "does not end your turn.",
+      type: 'text',
+      text: `Your parent agent id is ${encodedParentId}. Before you finish, send your result to that agent with `
+        + `send_message({ agent_id: ${encodedParentId}, message: "<self-contained result>" }). The parent shares `
+        + 'your workspace but does not automatically receive your transcript, tool output, or reasoning. Send '
+        + 'earlier messages as well when a finding changes what the parent should do next; sending a message '
+        + 'does not end your turn.',
     },
-  ];
+  ]
 }
 
 /**
@@ -101,32 +103,28 @@ export function withContinuableReturnGuidance(
  * @param continuable - whether the child accepts a later message.
  * @returns the model-facing opening line of the settlement notice.
  */
-function settlementSummary(
-  childId: SessionId,
-  stopReason: SubagentResult["stopReason"],
-  continuable: boolean,
-): string {
-  const subject = `Background subagent ${childId}`;
+function settlementSummary(childId: SessionId, stopReason: SubagentResult['stopReason'], continuable: boolean): string {
+  const subject = `Background subagent ${childId}`
   switch (stopReason) {
-    case "completed":
+    case 'completed':
       return continuable
         ? `${subject} finished and will do no further work unless you send it more.`
-        : `${subject} finished. It cannot receive follow-up messages.`;
-    case "aborted":
-      return `${subject} was stopped before it finished.`;
-    case "max-tokens":
-      return `${subject} ran out of room before it finished.`;
+        : `${subject} finished. It cannot receive follow-up messages.`
+    case 'aborted':
+      return `${subject} was stopped before it finished.`
+    case 'max-tokens':
+      return `${subject} ran out of room before it finished.`
     // A pre-step rejection — a hook deny, a policy plugin — discarded input
     // the child had claimed, so the parent must not treat the task as done.
-    case "refusal":
-      return `${subject} declined the task.`;
-    case "error":
-      return `${subject} failed before it finished.`;
+    case 'refusal':
+      return `${subject} declined the task.`
+    case 'error':
+      return `${subject} failed before it finished.`
     /* v8 ignore next 4 -- `SubagentResult['stopReason']` is merge-extensible, so this arm
      * needs a backend that adds a variant; an unnameable ending is reported as unfinished
      * rather than silently as success. */
     default:
-      return `${subject} ended abnormally (${String(stopReason)}) before it finished.`;
+      return `${subject} ended abnormally (${String(stopReason)}) before it finished.`
   }
 }
 
@@ -135,43 +133,41 @@ function settlementSummary(
  * @param childId - durable child session id named in the notice.
  * @param terminal - recorded terminal state for the settled Activation.
  * @param continuable - whether the child can accept another task.
+ * @param omitClosingText - replace the closing text with a note that the child's
+ *   last message to the parent already carries it.
  * @returns the durable user-message representation delivered to the parent.
  */
 export function createSettlementMessage(
   childId: SessionId,
   terminal: SubagentResult,
   continuable = true,
+  omitClosingText = false,
 ): ReturnType<typeof createUserMessage> {
-  const summary = settlementSummary(childId, terminal.stopReason, continuable);
+  const summary = settlementSummary(childId, terminal.stopReason, continuable)
   // Parent providers receive this notice as a user message and may reject
   // nontext assistant blocks. Keep this conversion local so SDK/UI consumers
   // retain the complete child output.
-  const closingText = terminal.output.flatMap((block) =>
-    block.type === "text" && block.text.length > 0 ? [block] : [],
-  );
+  const closingText = terminal.output.flatMap(block =>
+    block.type === 'text' && block.text.length > 0 ? [block] : [],
+  )
   return createUserMessage({
     content: [
-      { type: "text" as const, text: summary },
-      ...(closingText.length === 0
-        ? [{ type: "text" as const, text: "It left no closing message." }]
-        : [{ type: "text" as const, text: "Its closing message:" }, ...closingText]),
-      ...(terminal.structured !== undefined
-        ? [
-            {
-              type: "text" as const,
-              text: `Structured result: ${JSON.stringify(terminal.structured)}`,
-            },
-          ]
-        : []),
-      ...(terminal.diagnostic !== undefined
-        ? [{ type: "text" as const, text: terminal.diagnostic }]
-        : []),
+      { type: 'text' as const, text: summary },
+      ...omitClosingText
+        ? [{ type: 'text' as const, text: 'It sent you a message just before finishing, so its closing message is omitted.' }]
+        : closingText.length === 0
+          ? [{ type: 'text' as const, text: 'It left no closing message.' }]
+          : [{ type: 'text' as const, text: 'Its closing message:' }, ...closingText],
+      ...terminal.structured !== undefined
+        ? [{ type: 'text' as const, text: `Structured result: ${JSON.stringify(terminal.structured)}` }] : [],
+      ...terminal.diagnostic !== undefined
+        ? [{ type: 'text' as const, text: terminal.diagnostic }] : [],
     ],
     source: {
-      kind: "subagent-settled" as const,
-      form: "notice" as const,
+      kind: 'subagent-settled' as const,
+      form: 'notice' as const,
       summary: boundContextSummary(summary),
       senderSessionId: childId,
     },
-  });
+  })
 }

package/src/vendor/dsh-subagent/control-types.ts

@@ -5,12 +5,12 @@
  * @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";
+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'
 // Type-only: the Workspace registry's archive-admission family map this runtime merges `subagent` into.
-import type {} from "@deepseek-ai/dsh-workspace/types";
+import type {} from '@deepseek-ai/dsh-workspace/types'
 
 /**
  * Client-minted identity of one browser prompt, persisted on the exact accepted
@@ -19,128 +19,131 @@ import type {} from "@deepseek-ai/dsh-workspace/types";
  * vocabulary; that package depends on this one, so the brand is spelled here
  * rather than imported.
  */
-export type SubagentPromptRequestId = Branded<"session-request-id">;
+export type SubagentPromptRequestId = Branded<'session-request-id'>
 
 /** Shared child fields for recursive catalog listing. */
-export type SubagentCatalogRow = {
-  /** The durable child session id, stable across Activations. */
-  readonly id: SessionId;
-  /**
-   * Whether recursive catalog listing observed a resident Session. This
-   * does not encode a durable outcome or guarantee continuation delivery.
-   */
-  readonly activity: "running" | "inactive";
-} & (
-  | {
+export type SubagentCatalogRow =
+  & {
+    /** The durable child session id, stable across Activations. */
+    readonly id: SessionId
+    /**
+     * Whether recursive catalog listing observed a resident Session. This
+     * does not encode a durable outcome or guarantee continuation delivery.
+     */
+    readonly activity: 'running' | 'inactive'
+  } & (
+    | {
       /** A terminal one-shot child. */
-      readonly mode: "one-shot";
+      readonly mode: 'one-shot'
       /** Optional durable creation label from the parent catalog. */
-      readonly label?: string;
+      readonly label?: string
     }
-  | {
+    | {
       /** An external execution without a local child Session. */
-      readonly mode: "external";
+      readonly mode: 'external'
       /** Optional durable creation label from the parent catalog. */
-      readonly label?: string;
+      readonly label?: string
     }
-  | {
+    | {
       /** A resumable conversation. */
-      readonly mode: "continuable";
+      readonly mode: 'continuable'
       /** Durable creation label from the parent catalog. */
-      readonly label: string;
+      readonly label: string
     }
-);
+  )
 
 /**
  * One recursive catalog row. Traversal may also return diagnostics for
  * unknown catalog modes or unreadable child catalogs.
  */
 export type SubagentListEntry =
-  | (SubagentCatalogRow & {
-      readonly kind: "child";
-      /** Whether the child catalog contains a direct child. */
-      readonly hasChildren: boolean;
-    })
+  | SubagentCatalogRow & {
+    readonly kind: 'child'
+    /** Whether the child catalog contains a direct child. */
+    readonly hasChildren: boolean
+  }
   | {
-      readonly kind: "diagnostic";
-      /** The candidate's session id. */
-      readonly id: SessionId;
-      /**
-       * `corrupt` means the child catalog read found invalid or conflicting
-       * Session data; `unavailable` means it could not be read. Either failure
-       * stops that branch. `unsupported` means the parent catalog records an
-       * unknown child mode; its readable catalog is still traversed.
-       */
-      readonly reason: "corrupt" | "unsupported" | "unavailable";
-    };
+    readonly kind: 'diagnostic'
+    /** The candidate's session id. */
+    readonly id: SessionId
+    /**
+     * `corrupt` means the child catalog read found invalid or conflicting
+     * Session data; `unavailable` means it could not be read. Either failure
+     * stops that branch. `unsupported` means the parent catalog records an
+     * unknown child mode; its readable catalog is still traversed.
+     */
+    readonly reason: 'corrupt' | 'unsupported' | 'unavailable'
+  }
 
 /** Durable parent/child browsing address; unknown mode is resolved when child history is read. */
-export type SubagentAddress = {
-  readonly parentSessionId: SessionId;
-  readonly childSessionId: SessionId;
-} & (
-  | { readonly mode: "one-shot" }
-  | { readonly mode: "continuable" }
-  | { readonly mode: "unknown" }
-);
+export type SubagentAddress =
+  & {
+    readonly parentSessionId: SessionId
+    readonly childSessionId: SessionId
+  }
+  & (
+    | { readonly mode: 'one-shot' }
+    | { readonly mode: 'continuable' }
+    | { readonly mode: 'unknown' }
+  )
 
 /** One Agent inbox destination, as the prompt request selects it. */
-export type SubagentDelivery = SubagentPromptRequest["delivery"];
+export type SubagentDelivery = SubagentPromptRequest['delivery']
 
 /** 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;
+  readonly requestId: SubagentPromptRequestId
+  readonly parentSessionId: SessionId
+  readonly childSessionId: SessionId
   /** Required discriminator retained from the browser control address. */
-  readonly mode: "continuable";
+  readonly mode: 'continuable'
   /** Whether this message queues a later turn or targets the nearest step. */
-  readonly delivery: "queue" | "steer";
+  readonly delivery: 'queue' | 'steer'
   /**
    * 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[];
+  readonly content: readonly PromptContentPart[]
   /** Optional browser zone sampled for this exact human prompt. */
-  readonly clientTimeZone?: string;
+  readonly clientTimeZone?: string
 }
 
 /** Inbox identity returned once the continuation accepts one human message. */
 export interface SubagentPromptReceipt {
-  readonly messageId: MessageId;
+  readonly messageId: MessageId
 }
 
 /** Uniform acknowledgement that one interrupt request was admitted. */
 export interface SubagentInterruptReceipt {
-  readonly accepted: true;
+  readonly accepted: true
 }
 
 /**
  * Failure details the control surface answers with. Prompts and interrupts
  * share these failures with the Client Remote result.
  */
-declare module "@deepseek-ai/dsh-workspace/types" {
+declare module '@deepseek-ai/dsh-workspace/types' {
   interface SessionActivityKindMap {
     /** A subagent session delegated from this session (at any depth) is inside a turn. */
-    subagent: true;
+    subagent: true
   }
 }
 
-declare module "@deepseek-ai/dsh-typert-protocol" {
+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 };
+    'subagent/invalid-time-zone': { readonly value: string }
     /** No live Agent carries the addressed parent session. */
-    "subagent/parent-unavailable": { readonly parentSessionId: SessionId };
+    'subagent/parent-unavailable': { readonly parentSessionId: SessionId }
     /** The addressed child cannot take a continuation. */
-    "subagent/not-resumable": { readonly childSessionId: SessionId };
+    'subagent/not-resumable': { readonly childSessionId: SessionId }
     /** The claimed parent does not own the addressed child. */
-    "subagent/unauthorized": { readonly childSessionId: SessionId };
+    'subagent/unauthorized': { readonly childSessionId: SessionId }
     /** Image admission or model image-capability refusal. */
-    "subagent/attachment-invalid": { readonly reason: string };
+    'subagent/attachment-invalid': { readonly reason: string }
     /** The child exists but its inbox cannot admit the message now. */
-    "subagent/delivery-unavailable": { readonly childSessionId: SessionId };
+    'subagent/delivery-unavailable': { readonly childSessionId: SessionId }
   }
 }

package/src/vendor/dsh-subagent/control.ts

@@ -5,26 +5,26 @@
  * @module @deepseek-ai/dsh-subagent
  */
 
-import { AttachmentError } from "@deepseek-ai/dsh-attachment";
-import type { SessionId } from "@deepseek-ai/dsh-session";
-import { RemoteError } from "@deepseek-ai/dsh-typert-protocol";
-import { z } from "zod";
-import { SubagentError } from "./error.ts";
+import { AttachmentError } from '@deepseek-ai/dsh-attachment'
+import type { SessionId } from '@deepseek-ai/dsh-session'
+import { RemoteError } from '@deepseek-ai/dsh-typert-protocol'
+import { z } from 'zod'
+import { SubagentError } from './error.ts'
 
-const SESSION_ID_SCHEMA = z.string().min(1);
+const SESSION_ID_SCHEMA = z.string().min(1)
 const CONTROL_ID_SCHEMAS = {
-  "subagent.prompt": z.object({
+  'subagent.prompt': z.object({
     parentSessionId: SESSION_ID_SCHEMA,
     childSessionId: SESSION_ID_SCHEMA,
-    mode: z.literal("continuable"),
-    delivery: z.enum(["queue", "steer"]),
+    mode: z.literal('continuable'),
+    delivery: z.enum(['queue', 'steer']),
   }),
-  "subagent.interrupt": z.object({
+  'subagent.interrupt': z.object({
     parentSessionId: SESSION_ID_SCHEMA,
     childSessionId: SESSION_ID_SCHEMA,
-    mode: z.literal("continuable"),
+    mode: z.literal('continuable'),
   }),
-} as const;
+} as const
 
 /**
  * Apply the subagent payload checks that are stricter than generated
@@ -37,11 +37,9 @@ export function validateControlRequest(
   method: keyof typeof CONTROL_ID_SCHEMAS,
   payload: unknown,
 ): void {
-  const parsed = CONTROL_ID_SCHEMAS[method].safeParse(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,
-    });
+    throw new RemoteError('gateway/bad-request', `invalid payload for ${method}`, { issues: parsed.error.issues })
   }
 }
 
@@ -55,69 +53,55 @@ export function validateControlRequest(
  * @returns Never — the refusal is thrown.
  * @throws {RemoteError} always.
  */
-export function rejectPrompt(
-  error: unknown,
-  childSessionId: SessionId,
-  signal: AbortSignal,
-): never {
+export function rejectPrompt(error: unknown, childSessionId: SessionId, signal: AbortSignal): never {
   if (isCancellation(error, signal)) {
-    throw new RemoteError(
-      "gateway/cancelled",
-      "subagent prompt was cancelled",
-      {},
-      { cause: error },
-    );
+    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 },
-    );
+    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":
+      case 'MODEL_DOES_NOT_SUPPORT_IMAGES':
         throw new RemoteError(
-          "subagent/attachment-invalid",
+          'subagent/attachment-invalid',
           error.message,
           { reason: error.code },
           { cause: error },
-        );
-      case "NOT_RESUMABLE":
+        )
+      case 'NOT_RESUMABLE':
         throw new RemoteError(
-          "subagent/not-resumable",
-          "subagent cannot be resumed",
+          'subagent/not-resumable',
+          'subagent cannot be resumed',
           { childSessionId },
           { cause: error },
-        );
-      case "UNAUTHORIZED":
+        )
+      case 'UNAUTHORIZED':
         throw new RemoteError(
-          "subagent/unauthorized",
-          "subagent does not belong to this parent",
+          'subagent/unauthorized',
+          'subagent does not belong to this parent',
           { childSessionId },
           { cause: error },
-        );
-      case "DRAINING":
-      case "ACTIVATION_CLOSING":
-      case "ACTIVATION_LIMIT_REACHED":
-      case "CONTINUATION_UNAVAILABLE":
-      case "PERSISTENCE_UNAVAILABLE":
+        )
+      case 'DRAINING':
+      case 'ACTIVATION_CLOSING':
+      case 'ACTIVATION_LIMIT_REACHED':
+      case 'CONTINUATION_UNAVAILABLE':
+      case 'PERSISTENCE_UNAVAILABLE':
         throw new RemoteError(
-          "subagent/delivery-unavailable",
-          "subagent follow-up is temporarily unavailable",
+          '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;
+        break
     }
   }
-  throw new RemoteError("gateway/internal", "subagent prompt failed", {}, { cause: error });
+  throw new RemoteError('gateway/internal', 'subagent prompt failed', {}, { cause: error })
 }
 
 function isCancellation(error: unknown, signal: AbortSignal): boolean {
-  return signal.aborted || (error instanceof SubagentError && error.code === "CANCELLED");
+  return signal.aborted || (error instanceof SubagentError && error.code === 'CANCELLED')
 }

package/src/vendor/dsh-subagent/depth.ts

@@ -6,12 +6,12 @@
  * @module @deepseek-ai/dsh-subagent/depth
  */
 
-import type { Agent } from "@deepseek-ai/dsh-agent";
+import type { Agent } from '@deepseek-ai/dsh-agent'
 
-declare module "@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;
+    subagentDepth?: number
   }
 }
 
@@ -26,16 +26,13 @@ declare module "@deepseek-ai/dsh-agent" {
  * @throws if the runtime `AgentOptions.subagentDepth` is not a non-negative safe integer.
  */
 export function delegationDepthOf(agent: Agent): number {
-  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");
+  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);
+  return Math.max(agent.session.header.delegationDepth ?? 0, runtime ?? 0)
 }
 
 /**
@@ -43,13 +40,12 @@ export function delegationDepthOf(agent: Agent): number {
  * @param maxDepth - the optional runtime value to validate.
  */
 export function assertSubagentMaxDepth(maxDepth: unknown): void {
-  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");
+  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')
   }
 }