@morlay/dsh-subagent 0.0.6 → 0.0.7

package/src/vendor/dsh-subagent/child-agent.ts

@@ -0,0 +1,300 @@
+/**
+ * Shared in-process child composition: the delegation-depth budget, the
+ * durable session metadata, the resolved child `AgentOptions`, the delegated
+ * policy seed, and the scoped setup used by local activations.
+ *
+ * @module @deepseek-ai/dsh-subagent/child-agent
+ */
+
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent, AgentOptions, CreateAgentOptions } from "@deepseek-ai/dsh-agent";
+import type { SandboxMode } from "@deepseek-ai/dsh-sandbox";
+import type { Session, SessionId } from "@deepseek-ai/dsh-session";
+import type {} from "@deepseek-ai/dsh-system-prompt";
+import type { ToolRestriction } from "@deepseek-ai/dsh-tools";
+// Type-only: make `ctx.get('sandboxPolicy')`, `ctx.get('approval')`, and
+// `ctx.get('permissionPresets')` resolve to their services when composed — delegation consumes them
+// opportunistically (the documented `ctx.get` pattern), never as a hard dep —
+// and merge the inherited permission session-event payloads.
+import type {} from "@deepseek-ai/dsh-sandbox-policy";
+import type {} from "@deepseek-ai/dsh-user-approval";
+import type {} from "@deepseek-ai/dsh-permission-presets";
+// Type-only: make `ctx.get('agentPresets')` resolve to the preset roster when
+// composed — a child inherits its parent's composition opportunistically (the
+// documented `ctx.get` pattern), never as a hard dep. A rosterless deployment
+// keeps its model-facing rows on the host plane, where the child already sees
+// them through the tool registry's global layer.
+import type {} from "@deepseek-ai/dsh-agent-preset-registry";
+import { delegationDepthOf } from "./depth.ts";
+import { SubagentError } from "./error.ts";
+
+/** Thrown when starting a child would exceed the requested depth cap. */
+export class SubagentDepthError extends Error {
+  constructor(
+    public readonly attemptedDepth: number,
+    public readonly maxDepth: number,
+  ) {
+    super(`subagent depth ${attemptedDepth} exceeds maxDepth ${maxDepth}`);
+    this.name = "SubagentDepthError";
+  }
+}
+
+/**
+ * Resolve the child's delegation depth from its parent and enforce an optional
+ * cap. The persisted parent header is the monotone floor, so a resumed parent
+ * cannot delegate as if it were top-level.
+ * @param parent - the delegating parent agent.
+ * @param maxDepth - optional absolute cap the resolved depth must not exceed.
+ * @returns the child's non-negative safe-integer depth.
+ * @throws {SubagentDepthError} when the resolved depth exceeds `maxDepth`.
+ * @throws {RangeError} when the resolved depth leaves the safe-integer range.
+ */
+export function resolveChildDepth(parent: Agent, maxDepth: number | undefined): number {
+  const childDepth = delegationDepthOf(parent) + 1;
+  if (!Number.isSafeInteger(childDepth)) {
+    throw new RangeError("subagent child depth exceeds the safe-integer range");
+  }
+  if (maxDepth !== undefined && childDepth > maxDepth) {
+    throw new SubagentDepthError(childDepth, maxDepth);
+  }
+  return childDepth;
+}
+
+/**
+ * Resolve the parent values inherited by a child. The latest request header
+ * owns provider, model, and reasoning effort after request-time selection;
+ * creation options remain the fallback before the first request and retain
+ * the configured output-token limit.
+ * @param parent - delegating parent Agent.
+ * @returns detached Agent options for child-option merging.
+ */
+export function parentAgentOptionsForDelegation(parent: Agent): AgentOptions {
+  const requestConfig = parent.session.requestHeader()?.config;
+  if (requestConfig === undefined) return { ...parent.options };
+  const {
+    provider: _createdProvider,
+    model: _createdModel,
+    reasoningEffort: _createdReasoningEffort,
+    ...createdOptions
+  } = parent.options;
+  return {
+    ...createdOptions,
+    provider: requestConfig.provider,
+    model: requestConfig.model,
+    ...(requestConfig.reasoningEffort === undefined
+      ? {}
+      : { reasoningEffort: requestConfig.reasoningEffort }),
+  };
+}
+
+/**
+ * Resolve the child's `AgentOptions`: the parent's provider/model,
+ * reasoning-effort, and maxTokens values unless the request overrides them,
+ * stamped with the child's own delegation depth. Changing the route without
+ * naming an effort clears the parent's route-owned effort so the selected
+ * model resolves its own default.
+ * @param parent - the delegating parent whose route the child inherits.
+ * @param requested - per-child overrides, if any.
+ * @param childDepth - the resolved delegation depth to stamp.
+ * @returns the resolved options for `ctx.agents.create()`.
+ */
+export function resolveChildAgentOptions(
+  parent: Agent,
+  requested: AgentOptions | undefined,
+  childDepth: number,
+): AgentOptions {
+  const parentOptions = parentAgentOptionsForDelegation(parent);
+  const parentProvider = parentOptions.provider;
+  const parentModel = parentOptions.model;
+  const parentReasoningEffort = parentOptions.reasoningEffort;
+  const parentMaxTokens = parentOptions.maxTokens;
+  const resolved: AgentOptions = {
+    ...(parentProvider !== undefined ? { provider: parentProvider } : {}),
+    ...(parentModel !== undefined ? { model: parentModel } : {}),
+    ...(parentReasoningEffort !== undefined ? { reasoningEffort: parentReasoningEffort } : {}),
+    ...(parentMaxTokens !== undefined ? { maxTokens: parentMaxTokens } : {}),
+    ...requested,
+    subagentDepth: childDepth,
+  };
+  const routeChanged = resolved.provider !== parentProvider || resolved.model !== parentModel;
+  if (routeChanged && requested?.reasoningEffort === undefined) delete resolved.reasoningEffort;
+  return resolved;
+}
+
+/**
+ * Build the child session's durable creation metadata: the parent's workspace,
+ * its direct lineage, coarse product origin, the recursion budget that must
+ * survive persistence, the seed boundary that separates inherited parent
+ * history from child work, and the composition the child runs under.
+ *
+ * Omitted selection uses the parent's live composition, including any switch
+ * made while the parent was blank.
+ * @param parent - the delegating parent agent.
+ * @param childDepth - the resolved delegation depth to persist.
+ * @param isSeeded - whether this child inherits a parent-log prefix, including an explicitly empty one.
+ * @param selectedPreset - independent selection, or omission to inherit the parent.
+ * @returns the `meta` for `ctx.agents.create()`.
+ */
+export function childSessionMeta(
+  parent: Agent,
+  childDepth: number,
+  isSeeded: boolean,
+  selectedPreset?: string,
+): NonNullable<CreateAgentOptions["meta"]> {
+  const parentHeader = parent.session.header;
+  const agentPreset = selectedPreset ?? parent.ctx.get("agentPresets")?.composedPreset(parent.ctx);
+  return {
+    ...(parentHeader.cwd !== undefined ? { cwd: parentHeader.cwd } : {}),
+    ...(agentPreset === undefined ? {} : { agentPreset }),
+    parentSession: parentHeader.id,
+    isSeeded,
+    // Navigation classification only; the descriptor remains the authority
+    // for mode and continuation capability.
+    origin: "subagent",
+    // Durable: the recursion budget must survive persistence and resume.
+    delegationDepth: childDepth,
+  };
+}
+
+/** The scoped composition a child agent's creation window applies. */
+export interface ChildComposition {
+  /** Independently mounted preset; omission shares the parent's standing generation. */
+  readonly agentPreset?: string | undefined;
+  /** Historical descriptor persona reapplied only during cold resume. */
+  readonly persona?: string | undefined;
+  /** Historical descriptor tool restriction reapplied only during cold resume. */
+  readonly toolFilter?: ToolRestriction | undefined;
+}
+
+/**
+ * Model-facing delegation-scope statement for every in-process child. A
+ * runtime-context contribution rather than a system-prompt section, so the
+ * deployment's system prompt stays uniform across parents and children.
+ */
+export const SUBAGENT_DELEGATION_CONTEXT =
+  "You are a delegated subagent: your permission scope was fixed when you were started and cannot be " +
+  "widened from inside this session — operations that require approval are rejected automatically. " +
+  "When the task needs access beyond that scope, do not retry the denied operation; state the " +
+  "limitation in your reply so the delegating agent can handle it.";
+
+/**
+ * Compose a child before publication and restore historical descriptor overrides.
+ * Explicit selection mounts the named preset; omission synchronously joins the
+ * parent's current generation. Registrations belong to the child's scope.
+ * @param childCtx - the child agent's scoped creation context.
+ * @param parent - the delegating parent used when no preset is selected.
+ * @param composition - independent preset and any overrides read from a historical descriptor.
+ * @returns A promise when mounting an independent preset; otherwise completes synchronously.
+ */
+export function applyChildComposition(
+  childCtx: Context,
+  parent: Agent,
+  composition: ChildComposition,
+): void | Promise<void> {
+  if (composition.agentPreset !== undefined) {
+    const presets = childCtx.get("agentPresets");
+    if (presets === undefined) {
+      throw new SubagentError(
+        "selecting a child agent preset requires the agent-presets service",
+        "PRESET_UNAVAILABLE",
+      );
+    }
+    return presets.mount(childCtx, composition.agentPreset).then(() => {
+      applyChildOverrides(childCtx, composition);
+    });
+  }
+  childCtx.get("agentPresets")?.composeFrom(childCtx, parent.ctx);
+  applyChildOverrides(childCtx, composition);
+}
+
+function applyChildOverrides(childCtx: Context, composition: ChildComposition): void {
+  childCtx.systemPrompt.context({
+    name: "subagent:delegation",
+    order: childCtx.systemPrompt.getContextOrder("SUBAGENT_DELEGATION"),
+    text: SUBAGENT_DELEGATION_CONTEXT,
+  });
+  if (composition.persona !== undefined) {
+    childCtx.systemPrompt.section({
+      name: "deployment:persona-prefix",
+      order: childCtx.systemPrompt.getSectionOrder("DEPLOYMENT_PERSONA_PREFIX"),
+      text: composition.persona,
+    });
+  }
+  if (composition.toolFilter !== undefined) childCtx.tools.restrict(composition.toolFilter);
+}
+
+/** Policy seeded onto a child session's log at the delegation boundary. */
+export interface DelegatedPolicyOverrides {
+  /**
+   * The parent's current preset identity when it runs in Auto or Full access;
+   * the child keeps it under the pinned `never` approval policy.
+   */
+  readonly permissionPreset: "auto" | "danger-full-access" | undefined;
+  /** The parent session's explicit sandbox-mode override, or `undefined` without one. */
+  readonly sandboxMode: SandboxMode | undefined;
+  /**
+   * `'never'` whenever the approval capability is composed, `undefined`
+   * otherwise: a delegated child acts only within the sandbox scope fixed at
+   * delegation, so its asks are rejected deterministically.
+   */
+  readonly approvalPolicy: "never" | undefined;
+}
+
+/**
+ * Capture the permission state to seed into one delegation. Call synchronously before
+ * the child start's first await: a later parent switch belongs to the
+ * parent's future, not to this child. Auto and Full access identities are
+ * inherited only through the in-process DSH path so either can replace a stale
+ * same-bundle fork value. Only the parent session's explicit sandbox override
+ * is captured — never deployment defaults or one-shot grants — and the approval
+ * policy is pinned to `'never'` regardless of the parent's own policy.
+ * @param parent - the delegating parent agent.
+ * @returns the sandbox override (or `undefined` without one) and the approval pin.
+ */
+export function captureDelegatedPolicyOverrides(parent: Agent): DelegatedPolicyOverrides {
+  const preset = parent.ctx.get("permissionPresets")?.current(parent.session);
+  return {
+    permissionPreset: preset === "auto" || preset === "danger-full-access" ? preset : undefined,
+    sandboxMode: parent.ctx.get("sandboxPolicy")?.overrideOf(parent.session),
+    approvalPolicy: parent.ctx.get("approval") === undefined ? undefined : "never",
+  };
+}
+
+/**
+ * Append the captured delegation policy onto the child's own log as
+ * `source: 'delegation'` events inside the unpublished creation window, so the
+ * child's effective policy is reconstructable from its log alone. Appends land
+ * after any fork seed, so fresh policy wins stale seed state; later child
+ * switches still win over these events.
+ * @param childSession - the unpublished child's session.
+ * @param overrides - the policy captured at delegation.
+ */
+export function appendDelegatedPolicyOverrides(
+  childSession: Session,
+  overrides: DelegatedPolicyOverrides,
+): void {
+  if (overrides.sandboxMode !== undefined) {
+    childSession.append("sandbox/mode", { mode: overrides.sandboxMode, source: "delegation" });
+  }
+  if (overrides.approvalPolicy !== undefined) {
+    childSession.append("approval/policy", {
+      policy: overrides.approvalPolicy,
+      source: "delegation",
+    });
+  }
+  if (overrides.permissionPreset !== undefined) {
+    childSession.append("permission/preset", { preset: overrides.permissionPreset });
+  }
+}
+
+/** Identity and lineage inputs shared by every in-process child creation. */
+export interface ChildCreateInputs {
+  /** The child's reserved session id. */
+  readonly sessionId: SessionId;
+  /** The delegating parent agent. */
+  readonly parent: Agent;
+  /** The resolved delegation depth. */
+  readonly childDepth: number;
+  /** How many leading seed events came from the parent's log. */
+  readonly lineageSeedLength: number;
+}

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

@@ -0,0 +1,177 @@
+/**
+ * Model-visible messages owned by continuable-subagent orchestration.
+ *
+ * @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";
+
+/** Durable attribution for one model-authored message between Agents. */
+export interface AgentMessageSource {
+  readonly kind: "agent-message";
+  /** A message another agent addressed to this one (`relay` context form). */
+  readonly form: "relay";
+  /** Session id of the Agent whose tool call produced the message. */
+  readonly senderSessionId: SessionId;
+}
+
+/**
+ * Durable attribution for the runtime's own account of a continuable child
+ * settling. Deliberately a different kind from
+ * {@link AgentMessageSource}: an Agent message is content the sender chose,
+ * while this message is the manager stating what became of the child, and a
+ * transcript that merged them would credit the child with words it never wrote.
+ */
+export interface SubagentSettledMessageSource {
+  readonly kind: "subagent-settled";
+  /** A runtime account shown without expanding the row (`notice` context form). */
+  readonly form: "notice";
+  /** One-line account of how the child ended. */
+  readonly summary: string;
+  /** Session id of the child that settled. */
+  readonly senderSessionId: SessionId;
+}
+
+declare module "@deepseek-ai/dsh-llm" {
+  interface MessageSourceMap {
+    "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",
+    senderSessionId: sender.id,
+  };
+}
+
+/**
+ * Build the model-visible and durable representation of one adjacent-Agent message.
+ * @param sender - exact live Agent that authored the message.
+ * @param content - model-visible message blocks supplied by the sender.
+ * @returns the durable user-message representation delivered to the recipient.
+ */
+export function createAgentMessage(
+  sender: Agent,
+  content: ContentBlock[],
+): ReturnType<typeof createUserMessage> {
+  return createUserMessage({
+    content: [{ type: "text" as const, text: `Agent ${sender.id} sent a message: ` }, ...content],
+    source: agentMessageSource(sender),
+  });
+}
+
+/**
+ * Append adjacent-Agent return guidance to a continuable child's initial task.
+ * @param parentId - durable parent session id named in the guidance.
+ * @param prompt - initial model-visible task blocks.
+ * @returns task blocks followed by the continuable return guidance.
+ */
+export function withContinuableReturnGuidance(
+  parentId: SessionId,
+  prompt: ContentBlock[],
+): ContentBlock[] {
+  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.",
+    },
+  ];
+}
+
+/**
+ * One line telling a parent that a background child is finished and why, in
+ * the parent's own task vocabulary.
+ * @param childId - the durable child the parent knows by id.
+ * @param stopReason - how the child's last ordinary turn ended.
+ * @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}`;
+  switch (stopReason) {
+    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.`;
+    // 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.`;
+    /* 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.`;
+  }
+}
+
+/**
+ * Build the runtime-owned settlement notice from the child's nonempty closing text.
+ * @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.
+ * @returns the durable user-message representation delivered to the parent.
+ */
+export function createSettlementMessage(
+  childId: SessionId,
+  terminal: SubagentResult,
+  continuable = true,
+): ReturnType<typeof createUserMessage> {
+  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] : [],
+  );
+  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 }]
+        : []),
+    ],
+    source: {
+      kind: "subagent-settled" as const,
+      form: "notice" as const,
+      summary: boundContextSummary(summary),
+      senderSessionId: childId,
+    },
+  });
+}

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

@@ -0,0 +1,146 @@
+/**
+ * Client-safe recursive catalog rows and browser continuation requests,
+ * 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";
+// Type-only: the Workspace registry's archive-admission family map this runtime merges `subagent` into.
+import type {} from "@deepseek-ai/dsh-workspace/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">;
+
+/** 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";
+} & (
+  | {
+      /** A terminal one-shot child. */
+      readonly mode: "one-shot";
+      /** Optional durable creation label from the parent catalog. */
+      readonly label?: string;
+    }
+  | {
+      /** An external execution without a local child Session. */
+      readonly mode: "external";
+      /** Optional durable creation label from the parent catalog. */
+      readonly label?: string;
+    }
+  | {
+      /** A resumable conversation. */
+      readonly mode: "continuable";
+      /** Durable creation label from the parent catalog. */
+      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;
+    })
+  | {
+      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" }
+);
+
+/** One Agent inbox destination, as the prompt request selects it. */
+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;
+  /** Required discriminator retained from the browser control address. */
+  readonly mode: "continuable";
+  /** Whether this message queues a later turn or targets the nearest step. */
+  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[];
+  /** 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. Prompts and interrupts
+ * share these failures with the Client Remote result.
+ */
+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;
+  }
+}
+
+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 };
+  }
+}