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

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

@@ -27,34 +27,30 @@
  *
  * @module @deepseek-ai/dsh-subagent
  */
-import type { Volatile } from "@deepseek-ai/cordis";
+import type { Volatile } from '@deepseek-ai/cordis'
 
-import { Context } from "@deepseek-ai/cordis";
-import z from "@deepseek-ai/schemastery";
-import type {} from "@deepseek-ai/dsh-working-directory";
-import type {} from "@deepseek-ai/dsh-attachment";
-import { scopeTarget } from "@deepseek-ai/dsh-scope";
-import type { Scoped } from "@deepseek-ai/dsh-scope";
-import { assertObjectJsonSchema } from "@deepseek-ai/dsh-tools";
-import type { ContentBlock, MessageId, MessageSource } from "@deepseek-ai/dsh-llm";
-import type { Agent } from "@deepseek-ai/dsh-agent";
-import type { SessionId } from "@deepseek-ai/dsh-session";
-import { canonicalClientTimeZone } from "@deepseek-ai/dsh-util-time";
+import { Context, Service } from '@deepseek-ai/cordis'
+import z from '@deepseek-ai/schemastery'
+import type {} from '@deepseek-ai/dsh-working-directory'
+import type {} from '@deepseek-ai/dsh-attachment'
+import { scopeTarget } from '@deepseek-ai/dsh-scope'
+import type { Scoped } from '@deepseek-ai/dsh-scope'
+import { assertObjectJsonSchema } from '@deepseek-ai/dsh-tools'
+import type { ContentBlock, MessageId, MessageSource } from '@deepseek-ai/dsh-llm'
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import type { SessionId } from '@deepseek-ai/dsh-session'
+import { canonicalClientTimeZone } from '@deepseek-ai/dsh-util-time'
+import { Remote, RemoteError, TypertRemoteService, principalOf, type Principal } from '@deepseek-ai/dsh-typert-protocol'
 import {
-  Remote,
-  RemoteError,
-  TypertRemoteService,
-  principalOf,
-  type Principal,
-} from "@deepseek-ai/dsh-typert-protocol";
-import { rejectPrompt, validateControlRequest } from "./control.ts";
+  rejectPrompt, validateControlRequest,
+} from './control.ts'
 import type {
   SubagentDelivery,
   SubagentInterruptReceipt,
   SubagentPromptReceipt,
   SubagentPromptRequest,
   SubagentPromptRequestId,
-} from "./control-types.ts";
+} from './control-types.ts'
 import type {
   ContinuableCreateRequest,
   ContinuableCreateSpec,
@@ -67,30 +63,24 @@ import type {
   SubagentRunInfo,
   SubagentSendMessageOptions,
   SubagentStartRequest,
-} from "./types.ts";
-import { SubagentError } from "./error.ts";
-import { assertSubagentMaxDepth } from "./depth.ts";
-import { createActivationObserver, createLifecycleEmitter } from "./lifecycle.ts";
-import type { ActivationObserver, LifecycleEmitter } from "./lifecycle.ts";
-import SubagentManager from "./manager.ts";
-import {
-  listChildren as listSubagentChildren,
-  listDescendants as listSubagentDescendants,
-} from "./list-children.ts";
-import type { SubagentDescendantListEntry } from "./list-children.ts";
-import { installSubagentArchiveAdmission } from "./archive-admission.ts";
-import type { SubagentCatalogEntry } from "./projection-types.ts";
-import {
-  subagentIdentityProjectionDefinition,
-  subagentTimingProjectionDefinition,
-} from "./projection.ts";
-import { subagentCatalogProjectionDefinition } from "./catalog.ts";
-import { deliverSubagentPrompt } from "./internal.ts";
+} from './types.ts'
+import { SubagentError } from './error.ts'
+import { assertSubagentMaxDepth } from './depth.ts'
+import { createActivationObserver, createLifecycleEmitter } from './lifecycle.ts'
+import type { ActivationObserver, LifecycleEmitter } from './lifecycle.ts'
+import SubagentManager from './manager.ts'
+import { listChildren as listSubagentChildren, listDescendants as listSubagentDescendants } from './list-children.ts'
+import type { SubagentDescendantListEntry } from './list-children.ts'
+import { installSubagentArchiveAdmission } from './archive-admission.ts'
+import type { SubagentCatalogEntry } from './projection-types.ts'
+import { subagentIdentityProjectionDefinition, subagentTimingProjectionDefinition } from './projection.ts'
+import { subagentCatalogProjectionDefinition } from './catalog.ts'
+import { deliverSubagentPrompt } from './internal.ts'
 
-export type {} from "./catalog.ts";
-export * from "./out-of-process.ts";
-export { AssistantOutputFold, finalAssistantOutput } from "./assistant-output.ts";
-export { SubagentRunId } from "./types.ts";
+export type {} from './catalog.ts'
+export * from './out-of-process.ts'
+export { AssistantOutputFold, finalAssistantOutput } from './assistant-output.ts'
+export { SubagentRunId } from './types.ts'
 export type {
   ContinuableCreateRequest,
   ContinuableCreateSpec,
@@ -106,21 +96,21 @@ export type {
   ResolvedSubagentStartRequest,
   SubagentStopReason,
   SubagentStopReasonMap,
-} from "./types.ts";
+} from './types.ts'
 export {
   foldSubagentDescriptor,
   snapshotSubagentDescriptor,
   SUBAGENT_DESCRIPTOR_VERSION,
-} from "./descriptor.ts";
+} from './descriptor.ts'
 export type {
   ContinuableSubagentDescriptorData,
   ContinuableSubagentDescriptorInput,
   OneShotSubagentDescriptorData,
   SubagentDescriptorData,
-} from "./descriptor.ts";
-export { STRUCTURED_OUTPUT_TOOL } from "./structured.ts";
-export { SubagentError } from "./error.ts";
-export { assertSubagentMaxDepth, delegationDepthOf } from "./depth.ts";
+} from './descriptor.ts'
+export { STRUCTURED_OUTPUT_TOOL } from './structured.ts'
+export { SubagentError } from './error.ts'
+export { assertSubagentMaxDepth, delegationDepthOf } from './depth.ts'
 export {
   appendDelegatedPolicyOverrides,
   applyChildComposition,
@@ -130,21 +120,17 @@ export {
   resolveChildAgentOptions,
   resolveChildDepth,
   SubagentDepthError,
-} from "./child-agent.ts";
-export type { ChildComposition, DelegatedPolicyOverrides } from "./child-agent.ts";
-export type { AgentMessageSource, SubagentSettledMessageSource } from "./continuation-messages.ts";
-export type * from "./control-types.ts";
-export type { SubagentDescendantListEntry } from "./list-children.ts";
-export type { SubagentRunEndInfo, SubagentRunInfo } from "./types.ts";
-export type {
-  SubagentCatalogEntry,
-  SubagentIdentityProjection,
-  SubagentTimingProjection,
-} from "./projection-types.ts";
+} from './child-agent.ts'
+export type { ChildComposition, DelegatedPolicyOverrides } from './child-agent.ts'
+export type { AgentMessageSource, SubagentSettledMessageSource } from './continuation-messages.ts'
+export type * from './control-types.ts'
+export type { SubagentDescendantListEntry } from './list-children.ts'
+export type { SubagentRunEndInfo, SubagentRunInfo } from './types.ts'
+export type { SubagentCatalogEntry, SubagentIdentityProjection, SubagentTimingProjection } from './projection-types.ts'
 
-declare module "@deepseek-ai/cordis" {
+declare module '@deepseek-ai/cordis' {
   interface Context {
-    subagents: SubagentRuntime;
+    subagents: SubagentRuntime
   }
 
   interface Events {
@@ -153,13 +139,13 @@ declare module "@deepseek-ai/cordis" {
      * @param provider - the registered provider.
      * @mode emit
      */
-    "subagent/provider-added"(provider: SubagentProvider): void;
+    'subagent/provider-added'(provider: SubagentProvider): void
     /**
      * A provider left the registry. Accepted runs remain holder-owned.
      * @param name - the provider name that no longer resolves.
      * @mode emit
      */
-    "subagent/provider-removed"(name: string): void;
+    'subagent/provider-removed'(name: string): void
     /**
      * A provider established a published child. For in-process providers,
      * `ctx.agents.get(info.id)` resolves during this notification.
@@ -169,7 +155,7 @@ declare module "@deepseek-ai/cordis" {
      * @param info - the provider and published child identity.
      * @mode emit
      */
-    "subagent/start"(this: Scoped<SubagentRuntime>, info: SubagentRunInfo): void;
+    'subagent/start'(this: Scoped<SubagentRuntime>, info: SubagentRunInfo): void
     /**
      * A published child settled. Scope-filtered dispatch uses the same delegating
      * parent carrier as `subagent/start`, so the lifecycle pair reaches the
@@ -177,7 +163,7 @@ declare module "@deepseek-ai/cordis" {
      * @param info - the run identity and terminal outcome.
      * @mode emit
      */
-    "subagent/end"(this: Scoped<SubagentRuntime>, info: SubagentRunEndInfo): void;
+    'subagent/end'(this: Scoped<SubagentRuntime>, info: SubagentRunEndInfo): void
   }
 }
 
@@ -189,83 +175,65 @@ declare module "@deepseek-ai/cordis" {
  * Client reconciles its optimistic prompt against.
  */
 interface BrowserPromptSource {
-  readonly kind: "user";
-  readonly rpcId: SubagentPromptRequestId;
-  readonly clientTimeZone?: string;
+  readonly kind: 'user'
+  readonly rpcId: SubagentPromptRequestId
+  readonly clientTimeZone?: string
   /** Caller that submitted this follow-up, written only when it is not the owner; absent means the owner. */
-  readonly principal?: Principal;
+  readonly principal?: Principal
 }
 
 /** Host configuration for continuable subagent capacity. */
 export interface Config {
   /** Maximum live children sharing uninterrupted continuable parent links; defaults to 8. */
-  maxActiveSubagents: Volatile<number>;
+  maxActiveSubagents: Volatile<number>
   /** Default delegation depth for tools without an explicit limit; defaults to 1. */
-  maxDepth: Volatile<number>;
+  maxDepth: Volatile<number>
 }
 
 /** Named provider registry with managed activations, durable discovery, and local child messaging. */
 export class SubagentRuntime extends TypertRemoteService {
   static Config = z.object({
     maxDepth: z.number().step(1).min(0).max(Number.MAX_SAFE_INTEGER).default(1).volatile(),
-    maxActiveSubagents: z
-      .number()
-      .step(1)
-      .min(1)
-      .max(Number.MAX_SAFE_INTEGER)
-      .default(8)
-      .volatile(),
-  });
-  static inject = ["workingDirectory"];
-  private providers = new Map<string, SubagentProvider>();
-  private manager: SubagentManager | undefined;
+    maxActiveSubagents: z.number().step(1).min(1).max(Number.MAX_SAFE_INTEGER).default(8).volatile(),
+  })
+  static inject = ['workingDirectory', 'sessionProjections']
+  private providers = new Map<string, SubagentProvider>()
+  private manager: SubagentManager | undefined
   /**
    * The contained lifecycle-edge publisher. Built here because scoped dispatch
    * keys its carrier by this exact service instance, whose own context filter
    * composes into the carrier.
    */
-  private readonly emitLifecycle: LifecycleEmitter;
+  private readonly emitLifecycle: LifecycleEmitter
 
-  constructor(
-    ctx: Context,
-    private config: Config,
-  ) {
-    super(ctx, "subagents");
-    this.emitLifecycle = createLifecycleEmitter(this.ctx, (parent) => scopeTarget(this, parent));
-    ctx.inject(["agents"], (childCtx: Context) => {
-      const manager = new SubagentManager(
-        childCtx,
-        {
-          startExternal: (name, request) => {
-            const provider = this.expectProvider(name) as SubagentProvider &
-              Required<Pick<SubagentProvider, "start">>;
-            return provider.start(request);
-          },
-          prepareContinuable: (name, request) => this.prepareContinuable(name, request),
-          observeActivation: (provider, childId, parent) =>
-            this.observeActivation(provider, childId, parent),
+  constructor(ctx: Context, private config: Config) {
+    super(ctx, 'subagents')
+    this.emitLifecycle = createLifecycleEmitter(this.ctx, parent => scopeTarget(this, parent))
+    ctx.inject(['agents'], (childCtx: Context) => {
+      const manager = new SubagentManager(childCtx, {
+        startExternal: (name, request) => {
+          const provider = this.expectProvider(name) as SubagentProvider & Required<Pick<SubagentProvider, 'start'>>
+          return provider.start(request)
         },
-        () => this.config.maxActiveSubagents.get(),
-      );
-      this.manager = manager;
-      childCtx.effect(
-        () => () => {
-          /* v8 ignore else -- one injected binding owns the slot until its fiber disposes. */
-          if (this.manager === manager) this.manager = undefined;
-        },
-        "subagents.managerBinding()",
-      );
-    });
-    ctx.inject(["sessionProjections"], (projectionCtx) => {
-      projectionCtx.sessionProjections.register(subagentCatalogProjectionDefinition);
-      projectionCtx.sessionProjections.register(subagentTimingProjectionDefinition);
-      projectionCtx.sessionProjections.register(subagentIdentityProjectionDefinition);
-    });
+        prepareContinuable: (name, request) => this.prepareContinuable(name, request),
+        observeActivation: (provider, childId, parent) => this.observeActivation(provider, childId, parent),
+      }, () => this.config.maxActiveSubagents.get())
+      this.manager = manager
+      childCtx.effect(() => () => {
+        /* v8 ignore else -- one injected binding owns the slot until its fiber disposes. */
+        if (this.manager === manager) this.manager = undefined
+      }, 'subagents.managerBinding()')
+    })
     // Archive admission: this runtime is the owner that knows which live
     // children descend from a Session and how a parent stops them.
-    ctx.inject(["agents"], (agentsCtx: Context) => {
-      installSubagentArchiveAdmission(agentsCtx);
-    });
+    ctx.inject(['agents'], (agentsCtx: Context) => { installSubagentArchiveAdmission(agentsCtx) })
+  }
+
+  protected async [Service.init](): Promise<void> {
+    const { sessionProjections } = this.ctx
+    await sessionProjections.register(subagentCatalogProjectionDefinition)
+    await sessionProjections.register(subagentTimingProjectionDefinition)
+    await sessionProjections.register(subagentIdentityProjectionDefinition)
   }
 
   /**
@@ -273,12 +241,12 @@ export class SubagentRuntime extends TypertRemoteService {
    * @param configured - Explicit tool limit, or provider-managed for external delegation.
    * @returns The numeric limit, or undefined when the provider owns depth enforcement.
    */
-  resolveMaxDepth(configured?: number | "provider-managed"): number | undefined {
-    if (configured === "provider-managed") return undefined;
-    if (configured !== undefined) return configured;
-    const depth = this.config.maxDepth.get();
-    assertSubagentMaxDepth(depth);
-    return depth;
+  resolveMaxDepth(configured?: number | 'provider-managed'): number | undefined {
+    if (configured === 'provider-managed') return undefined
+    if (configured !== undefined) return configured
+    const depth = this.config.maxDepth.get()
+    assertSubagentMaxDepth(depth)
+    return depth
   }
 
   /**
@@ -286,15 +254,14 @@ export class SubagentRuntime extends TypertRemoteService {
    * @param spec - local task, reserved child id, and result recipient.
    * @returns activation with its accepted initial message id.
    */
-  startActivation(
-    spec: SubagentActivationSpec & { readonly childId: SessionId },
-  ): Promise<SubagentActivation & { readonly messageId: MessageId }>;
+  startActivation(spec: SubagentActivationSpec & { readonly childId: SessionId }):
+  Promise<SubagentActivation & { readonly messageId: MessageId }>
   /**
    * Start a local or external child.
    * @param spec - task, backend, and result recipient.
    * @returns activation with a message id only for local children.
    */
-  startActivation(spec: SubagentActivationSpec): Promise<SubagentActivation>;
+  startActivation(spec: SubagentActivationSpec): Promise<SubagentActivation>
   /**
    * Establish a managed child with backend-specific execution capabilities.
    * @param spec - task, backend, and result recipient.
@@ -302,26 +269,20 @@ export class SubagentRuntime extends TypertRemoteService {
    * childId requires a local backend and guarantees an accepted messageId.
    */
   async startActivation(spec: SubagentActivationSpec): Promise<SubagentActivation> {
-    const provider = this.expectProvider(spec.provider);
+    const provider = this.expectProvider(spec.provider)
     if (spec.childId !== undefined && provider.prepareContinuable === undefined) {
-      throw new SubagentError(
-        "reserved child ids require a local backend",
-        "UNSUPPORTED_CAPABILITY",
-      );
+      throw new SubagentError('reserved child ids require a local backend', 'UNSUPPORTED_CAPABILITY')
     }
-    assertSubagentMaxDepth(spec.request.maxDepth);
-    this.assertCapabilities(provider, { ...spec.request, signal: spec.signal });
-    const manager = this.requireManager();
-    if (this.ctx.get("agents")?.get(spec.request.parent.id) !== spec.request.parent) {
-      throw new SubagentError(
-        "subagent creation requires the exact live parent agent",
-        "UNAUTHORIZED",
-      );
+    assertSubagentMaxDepth(spec.request.maxDepth)
+    this.assertCapabilities(provider, { ...spec.request, signal: spec.signal })
+    const manager = this.requireManager()
+    if (this.ctx.get('agents')?.get(spec.request.parent.id) !== spec.request.parent) {
+      throw new SubagentError('subagent creation requires the exact live parent agent', 'UNAUTHORIZED')
     }
-    if (spec.request.outputSchema !== undefined) assertObjectJsonSchema(spec.request.outputSchema);
+    if (spec.request.outputSchema !== undefined) assertObjectJsonSchema(spec.request.outputSchema)
     return provider.prepareContinuable === undefined
       ? manager.startExternal(spec)
-      : manager.startLocal(spec);
+      : manager.startLocal(spec)
   }
 
   /**
@@ -331,7 +292,7 @@ export class SubagentRuntime extends TypertRemoteService {
    * @returns whether work was joined; hosts recheck parent idle after true.
    */
   async waitForChildren(parent: Agent): Promise<boolean> {
-    return this.manager?.waitForChildren(parent) ?? false;
+    return this.manager?.waitForChildren(parent) ?? false
   }
 
   /**
@@ -354,7 +315,7 @@ export class SubagentRuntime extends TypertRemoteService {
     content: ContentBlock[],
     options: SubagentSendMessageOptions,
   ): Promise<MessageId> {
-    return this.requireManager().sendMessage(sender, targetId, content, options);
+    return this.requireManager().sendMessage(sender, targetId, content, options)
   }
 
   /**
@@ -377,9 +338,9 @@ export class SubagentRuntime extends TypertRemoteService {
     signal: AbortSignal,
     delivery: SubagentDelivery,
   ): Promise<MessageId> {
-    return delivery === "steer"
+    return delivery === 'steer'
       ? this.requireManager().steerPrompt(parent, childId, content, source, signal)
-      : this.requireManager().queuePrompt(parent, childId, content, source, signal);
+      : this.requireManager().queuePrompt(parent, childId, content, source, signal)
   }
 
   /**
@@ -398,7 +359,7 @@ export class SubagentRuntime extends TypertRemoteService {
    *   live target.
    */
   interrupt(targetSessionId: SessionId, authority: SubagentInterruptAuthority): void {
-    this.manager?.interrupt(targetSessionId, authority);
+    this.manager?.interrupt(targetSessionId, authority)
   }
 
   /**
@@ -412,10 +373,10 @@ export class SubagentRuntime extends TypertRemoteService {
    * @throws an aggregate error after all branches settle when any failed.
    */
   async drainDescendants(parents: readonly Agent[]): Promise<void> {
-    const manager = this.manager;
+    const manager = this.manager
     // An absent activation manager cannot own materialized children.
-    if (manager === undefined) return;
-    await manager.drainDescendants(parents);
+    if (manager === undefined) return
+    await manager.drainDescendants(parents)
   }
 
   /**
@@ -429,9 +390,9 @@ export class SubagentRuntime extends TypertRemoteService {
    *   different parent or the supplied parent identity is stale.
    */
   async drainChildren(parent: Agent, childIds: readonly SessionId[]): Promise<void> {
-    const manager = this.manager;
-    if (manager === undefined) return;
-    await manager.drainChildren(parent, childIds);
+    const manager = this.manager
+    if (manager === undefined) return
+    await manager.drainChildren(parent, childIds)
   }
 
   /**
@@ -444,7 +405,7 @@ export class SubagentRuntime extends TypertRemoteService {
    * @throws SessionQueryError when the parent cannot be read or the query is cancelled.
    */
   listChildren(parentSessionId: SessionId, signal?: AbortSignal): Promise<SubagentCatalogEntry[]> {
-    return listSubagentChildren(this.ctx, parentSessionId, signal);
+    return listSubagentChildren(this.ctx, parentSessionId, signal)
   }
 
   /**
@@ -463,11 +424,8 @@ export class SubagentRuntime extends TypertRemoteService {
    * @throws {@link SubagentError} when listing dependencies are unavailable or the caller cancels.
    * @throws SessionQueryError when the root catalog cannot be read.
    */
-  listDescendants(
-    rootSessionId: SessionId,
-    signal?: AbortSignal,
-  ): Promise<SubagentDescendantListEntry[]> {
-    return listSubagentDescendants(this.ctx, rootSessionId, signal);
+  listDescendants(rootSessionId: SessionId, signal?: AbortSignal): Promise<SubagentDescendantListEntry[]> {
+    return listSubagentDescendants(this.ctx, rootSessionId, signal)
   }
 
   /**
@@ -488,52 +446,45 @@ export class SubagentRuntime extends TypertRemoteService {
    *   `subagent/not-resumable`, `subagent/unauthorized`,
    *   `subagent/delivery-unavailable`, `gateway/cancelled`, or `gateway/internal`.
    */
-  @Remote("prompt")
-  async prompt(
-    request: SubagentPromptRequest,
-    signal: AbortSignal,
-  ): Promise<SubagentPromptReceipt> {
-    const { parentSessionId, childSessionId, clientTimeZone, delivery } = request;
-    validateControlRequest("subagent.prompt", request);
-    const canonicalTimeZone =
-      clientTimeZone === undefined ? undefined : canonicalClientTimeZone(clientTimeZone);
+  @Remote('prompt')
+  async prompt(request: SubagentPromptRequest, signal: AbortSignal): Promise<SubagentPromptReceipt> {
+    const { parentSessionId, childSessionId, clientTimeZone, delivery } = request
+    validateControlRequest('subagent.prompt', request)
+    const canonicalTimeZone = clientTimeZone === undefined
+      ? undefined
+      : canonicalClientTimeZone(clientTimeZone)
     if (clientTimeZone !== undefined && canonicalTimeZone === undefined) {
       throw new RemoteError(
-        "subagent/invalid-time-zone",
-        "clientTimeZone must be UTC or a valid IANA Area/Location name",
+        'subagent/invalid-time-zone',
+        'clientTimeZone must be UTC or a valid IANA Area/Location name',
         { value: clientTimeZone },
-      );
+      )
     }
-    const parent = this.ctx.get("agents")?.get(parentSessionId);
+    const parent = this.ctx.get('agents')?.get(parentSessionId)
     if (parent === undefined) {
       throw new RemoteError(
-        "subagent/parent-unavailable",
+        'subagent/parent-unavailable',
         `parent session "${parentSessionId}" is not live`,
         { parentSessionId },
-      );
+      )
     }
-    const principal = principalOf(this.ctx.invocation);
+    const principal = principalOf(this.ctx.invocation)
     const source: BrowserPromptSource = {
-      kind: "user",
+      kind: 'user',
       rpcId: request.requestId,
       ...(canonicalTimeZone === undefined ? {} : { clientTimeZone: canonicalTimeZone }),
       ...(principal === undefined ? {} : { principal }),
-    };
+    }
     try {
       // Admission precedes delivery: image parts become durable references
       // here, so the child inbox only ever accepts Host-persisted attachments.
-      let content: ContentBlock[];
-      if (
-        request.content.every(
-          (part): part is { readonly type: "text"; readonly text: string } => part.type === "text",
-        )
-      ) {
-        content = request.content.map((part) => ({ type: "text", text: part.text }));
+      let content: ContentBlock[]
+      if (request.content.every((part): part is { readonly type: 'text'; readonly text: string } => part.type === 'text')) {
+        content = request.content.map(part => ({ type: 'text', text: part.text }))
       } else {
-        const attachments = this.ctx.get("attachments");
-        if (attachments === undefined)
-          throw new Error("subagent image prompt requires an attachment store");
-        content = await attachments.admitPromptContent(request.content);
+        const attachments = this.ctx.get('attachments')
+        if (attachments === undefined) throw new Error('subagent image prompt requires an attachment store')
+        content = await attachments.admitPromptContent(request.content)
       }
       return {
         messageId: await this[deliverSubagentPrompt](
@@ -544,9 +495,9 @@ export class SubagentRuntime extends TypertRemoteService {
           signal,
           delivery,
         ),
-      };
+      }
     } catch (error: unknown) {
-      return rejectPrompt(error, childSessionId, signal);
+      return rejectPrompt(error, childSessionId, signal)
     }
   }
 
@@ -564,27 +515,27 @@ export class SubagentRuntime extends TypertRemoteService {
    *   `subagent/unauthorized` when the address does not own the live target,
    *   otherwise `gateway/internal`.
    */
-  @Remote("interruptByParent")
+  @Remote('interruptByParent')
   interruptByParent(
     childSessionId: SessionId,
     parentSessionId: SessionId,
-    mode: "continuable",
+    mode: 'continuable',
   ): SubagentInterruptReceipt {
-    validateControlRequest("subagent.interrupt", { childSessionId, parentSessionId, mode });
+    validateControlRequest('subagent.interrupt', { childSessionId, parentSessionId, mode })
     try {
-      this.interrupt(childSessionId, { kind: "user", parentSessionId });
+      this.interrupt(childSessionId, { kind: 'user', parentSessionId })
     } catch (error: unknown) {
-      if (error instanceof SubagentError && error.code === "UNAUTHORIZED") {
+      if (error instanceof SubagentError && error.code === '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 },
-        );
+        )
       }
-      throw new RemoteError("gateway/internal", "subagent interrupt failed", {}, { cause: error });
+      throw new RemoteError('gateway/internal', 'subagent interrupt failed', {}, { cause: error })
     }
-    return { accepted: true };
+    return { accepted: true }
   }
 
   /**
@@ -596,33 +547,24 @@ export class SubagentRuntime extends TypertRemoteService {
    * @returns the exact Cordis effect disposer.
    */
   registerProvider(provider: SubagentProvider): () => void {
-    const name = provider.name;
+    const name = provider.name
     if (provider.start === undefined && provider.prepareContinuable === undefined) {
-      throw new SubagentError(
-        `subagent provider "${name}" must implement start or prepareContinuable`,
-        "UNSUPPORTED_CAPABILITY",
-      );
+      throw new SubagentError(`subagent provider "${name}" must implement start or prepareContinuable`, 'UNSUPPORTED_CAPABILITY')
     }
     // oxlint-disable-next-line typescript/no-misused-promises -- synchronous disposer
-    return this.ctx.effect(
-      function* (this: SubagentRuntime) {
-        if (this.providers.has(name)) {
-          throw new SubagentError(
-            `a subagent provider named "${name}" is already registered`,
-            "DUPLICATE_PROVIDER",
-          );
-        }
-        this.providers.set(name, provider);
-        yield () => {
-          this.providers.delete(name);
-          this.emitLifecycle("subagent/provider-removed", name);
-        };
-        // A throwing added-listener unwinds the yielded rollback, matching the
-        // repository's fail-loud registration semantics.
-        this.ctx.emit("subagent/provider-added", provider);
-      }.bind(this),
-      "subagents.registerProvider()",
-    );
+    return this.ctx.effect(function* (this: SubagentRuntime) {
+      if (this.providers.has(name)) {
+        throw new SubagentError(`a subagent provider named "${name}" is already registered`, 'DUPLICATE_PROVIDER')
+      }
+      this.providers.set(name, provider)
+      yield () => {
+        this.providers.delete(name)
+        this.emitLifecycle('subagent/provider-removed', name)
+      }
+      // A throwing added-listener unwinds the yielded rollback, matching the
+      // repository's fail-loud registration semantics.
+      this.ctx.emit('subagent/provider-added', provider)
+    }.bind(this), 'subagents.registerProvider()')
   }
 
   /**
@@ -631,7 +573,7 @@ export class SubagentRuntime extends TypertRemoteService {
    * @returns the provider, or undefined when absent.
    */
   getProvider(name: string): SubagentProvider | undefined {
-    return this.providers.get(name);
+    return this.providers.get(name)
   }
 
   /**
@@ -639,7 +581,7 @@ export class SubagentRuntime extends TypertRemoteService {
    * @returns the registered names.
    */
   list(): string[] {
-    return [...this.providers.keys()];
+    return [...this.providers.keys()]
   }
 
   /**
@@ -651,29 +593,28 @@ export class SubagentRuntime extends TypertRemoteService {
     name: string,
     request: ContinuableCreateRequest,
   ): Promise<ContinuableCreateSpec> {
-    const provider = this.expectProvider(name) as SubagentProvider &
-      Required<Pick<SubagentProvider, "prepareContinuable">>;
-    return provider.prepareContinuable(request);
+    const provider = this.expectProvider(name) as SubagentProvider & Required<Pick<SubagentProvider, 'prepareContinuable'>>
+    return provider.prepareContinuable(request)
   }
 
   /** Look up a provider for dispatch or fail loud. */
   private expectProvider(name: string): SubagentProvider {
-    const provider = this.providers.get(name);
+    const provider = this.providers.get(name)
     if (provider === undefined) {
-      throw new SubagentError(`no subagent provider registered for "${name}"`, "NO_PROVIDER");
+      throw new SubagentError(`no subagent provider registered for "${name}"`, 'NO_PROVIDER')
     }
-    return provider;
+    return provider
   }
 
   /** Resolve the subagent manager or fail loud. */
   private requireManager(): SubagentManager {
     if (this.manager === undefined) {
       throw new SubagentError(
-        "continuable subagents require the agents service",
-        "CONTINUATION_UNAVAILABLE",
-      );
+        'continuable subagents require the agents service',
+        'CONTINUATION_UNAVAILABLE',
+      )
     }
-    return this.manager;
+    return this.manager
   }
 
   /**
@@ -685,34 +626,32 @@ export class SubagentRuntime extends TypertRemoteService {
     childId: SessionId,
     parent: Agent,
   ): ActivationObserver {
-    return createActivationObserver(this.emitLifecycle, provider, childId, parent);
+    return createActivationObserver(this.emitLifecycle, provider, childId, parent)
   }
 
   /** Reject the first requested capability that the provider lacks. */
   private assertCapabilities(provider: SubagentProvider, request: SubagentStartRequest): void {
-    if (
-      request.agentPreset !== undefined &&
-      (!provider.capabilities.agentPreset || provider.inheritsParentContext)
-    ) {
+    if (request.agentPreset !== undefined && (!provider.capabilities.agentPreset || provider.inheritsParentContext)) {
       throw new SubagentError(
         `subagent provider "${provider.name}" does not support independent agent preset selection`,
-        "UNSUPPORTED_CAPABILITY",
-      );
+        'UNSUPPORTED_CAPABILITY',
+      )
     }
     const needs: { when: boolean; cap: keyof SubagentCapabilities }[] = [
-      { when: request.agentOptions !== undefined, cap: "agentOptions" },
-      { when: request.outputSchema !== undefined, cap: "outputSchema" },
-      { when: request.maxDepth !== undefined, cap: "depthLimit" },
-    ];
+      { when: request.agentOptions !== undefined, cap: 'agentOptions' },
+      { when: request.outputSchema !== undefined, cap: 'outputSchema' },
+      { when: request.maxDepth !== undefined, cap: 'depthLimit' },
+    ]
     for (const { when, cap } of needs) {
       if (when && !provider.capabilities[cap]) {
         throw new SubagentError(
           `subagent provider "${provider.name}" does not support the "${cap}" capability`,
-          "UNSUPPORTED_CAPABILITY",
-        );
+          'UNSUPPORTED_CAPABILITY',
+        )
       }
     }
   }
+
 }
 
-export default SubagentRuntime;
+export default SubagentRuntime