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

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

@@ -2,19 +2,19 @@
  * @module @deepseek-ai/dsh-subagent/activation
  */
 
-import type { Agent, AgentHandle } from "@deepseek-ai/dsh-agent";
-import type { SessionId, SessionLogOffset } from "@deepseek-ai/dsh-session";
-import { assertNever } from "@deepseek-ai/dsh-util-values";
-import { finalAssistantOutput } from "./assistant-output.ts";
-import { epochStopReason } from "./lifecycle.ts";
-import type { ActivationObserver } from "./lifecycle.ts";
-import { SubagentError } from "./error.ts";
-import type { StructuredAttachment } from "./structured.ts";
-import type { SubagentResult, SubagentRun } from "./types.ts";
+import type { Agent, AgentHandle } from '@deepseek-ai/dsh-agent'
+import type { SessionId, SessionLogOffset } from '@deepseek-ai/dsh-session'
+import { assertNever } from '@deepseek-ai/dsh-util-values'
+import { finalAssistantOutput } from './assistant-output.ts'
+import { epochStopReason } from './lifecycle.ts'
+import type { ActivationObserver } from './lifecycle.ts'
+import { SubagentError } from './error.ts'
+import type { StructuredAttachment } from './structured.ts'
+import type { SubagentResult, SubagentRun } from './types.ts'
 
 /** Process-local slots shared through uninterrupted continuable parent links. */
 export class ActivationPool {
-  private readonly slots = new Set<symbol>();
+  private readonly slots = new Set<symbol>()
 
   /**
    * Reserve before reconstruction; release also tolerates unpublished rollback.
@@ -24,16 +24,14 @@ export class ActivationPool {
   reserve(capacity: number): () => void {
     if (this.slots.size >= capacity) {
       throw new SubagentError(
-        `subagent limit reached (active child limit: ${capacity}); wait for an existing child to finish ` +
-          "or complete this work with the current agents",
-        "ACTIVATION_LIMIT_REACHED",
-      );
+        `subagent limit reached (active child limit: ${capacity}); wait for an existing child to finish `
+        + 'or complete this work with the current agents',
+        'ACTIVATION_LIMIT_REACHED',
+      )
     }
-    const slot = Symbol();
-    this.slots.add(slot);
-    return () => {
-      this.slots.delete(slot);
-    };
+    const slot = Symbol()
+    this.slots.add(slot)
+    return () => { this.slots.delete(slot) }
   }
 }
 
@@ -43,61 +41,67 @@ export class ActivationPool {
  */
 interface ActivationBase {
   /** Shared capacity for this Activation and all its managed descendants. */
-  readonly pool: ActivationPool;
+  readonly pool: ActivationPool
   /** Return this epoch's slot after its handle has finished disposal. */
-  readonly releaseSlot: () => void;
+  readonly releaseSlot: () => void
   /** The durable child this Activation is an epoch of. */
-  readonly childId: SessionId;
-  readonly parent: Agent;
-  readonly delivery: "parent" | "caller";
-  readonly result: PromiseWithResolvers<SubagentResult>;
+  readonly childId: SessionId
+  readonly parent: Agent
+  readonly delivery: 'parent' | 'caller'
+  readonly result: PromiseWithResolvers<SubagentResult>
   /** Published synchronously before teardown; subsequent callers share this transaction. */
-  closing: Promise<void> | undefined;
+  closing: Promise<void> | undefined
   /**
    * Exact live Agent ancestry observed when this Activation materialized.
    * Weak membership preserves host-scope identity across an intermediate
    * ancestor leaving the registry without retaining that ancestor's runtime.
    */
-  readonly ancestry: WeakSet<Agent>;
+  readonly ancestry: WeakSet<Agent>
   /**
    * Session ids of the child Activations this one owns. Because one Session has
    * at most one live Activation, the id identifies the live child without
    * another runtime-incarnation reference. Non-empty blocks settlement.
    */
-  readonly ownedChildren: Set<SessionId>;
+  readonly ownedChildren: Set<SessionId>
   /** The lifecycle observer that emits this epoch's start and terminal edges. */
-  readonly observer: ActivationObserver;
+  readonly observer: ActivationObserver
   /**
    * Whether any delivery to this child was ever accepted. A materialization
    * rolled back before its first acceptance is a child the caller was told does
    * not exist, so its teardown owes the parent no settlement account.
    */
-  announced: boolean;
+  announced: boolean
 }
 
 /** Resources retained only for the selected execution kind. */
 export type ActivationResource =
   | {
-      readonly kind: "local";
-      readonly handle: AgentHandle;
-      readonly outputStart: SessionLogOffset;
-      readonly structured: StructuredAttachment | undefined;
-      /** Latest live failure not superseded by a later committed turn ending. */
-      failureAt: SessionLogOffset | undefined;
-      /** Renewed when local settlement must recheck input or owned children. */
-      poke: PromiseWithResolvers<void>;
-    }
+    readonly kind: 'local'
+    readonly handle: AgentHandle
+    readonly outputStart: SessionLogOffset
+    readonly structured: StructuredAttachment | undefined
+    /** Latest live failure not superseded by a later committed turn ending. */
+    failureAt: SessionLogOffset | undefined
+    /** Renewed when local settlement must recheck input or owned children. */
+    poke: PromiseWithResolvers<void>
+    /**
+     * Whether this child's settlement notice omits its closing text: true while
+     * the child's last logged tool call was a message to its direct parent and
+     * no input was claimed since.
+     */
+    omitClosingText: boolean
+  }
   | {
-      readonly kind: "external";
-      readonly run: SubagentRun;
-      readonly controller: AbortController;
-    };
+    readonly kind: 'external'
+    readonly run: SubagentRun
+    readonly controller: AbortController
+  }
 
 /** One managed execution period with its provider-specific resources. */
-export type Activation = ActivationBase & ActivationResource;
+export type Activation = ActivationBase & ActivationResource
 
 /** Local residency with input admission and Session-backed result capture. */
-export type LocalActivation = Extract<Activation, { kind: "local" }>;
+export type LocalActivation = Extract<Activation, { kind: 'local' }>
 
 /**
  * Read the live Agent retained by local execution.
@@ -105,7 +109,7 @@ export type LocalActivation = Extract<Activation, { kind: "local" }>;
  * @returns the local Agent, absent for an external run.
  */
 export function activationAgent(activation: Activation): Agent | undefined {
-  return activation.kind === "local" ? activation.handle.agent : undefined;
+  return activation.kind === 'local' ? activation.handle.agent : undefined
 }
 
 /**
@@ -116,16 +120,11 @@ export function activationAgent(activation: Activation): Agent | undefined {
  */
 export function requireLocalActivation(activation: Activation): LocalActivation {
   switch (activation.kind) {
-    case "local":
-      return activation;
-    case "external":
-      throw new SubagentError(
-        `subagent "${activation.childId}" does not accept follow-up input`,
-        "NOT_CONTINUABLE",
-      );
+    case 'local': return activation
+    case 'external':
+      throw new SubagentError(`subagent "${activation.childId}" does not accept follow-up input`, 'NOT_CONTINUABLE')
     /* v8 ignore next 2 -- Both execution kinds are handled above. */
-    default:
-      return assertNever(activation);
+    default: return assertNever(activation)
   }
 }
 
@@ -135,22 +134,18 @@ export function requireLocalActivation(activation: Activation): LocalActivation
  * @param wake - notify its settlement watcher when failure changes readiness.
  */
 export function observeLocalFailure(activation: LocalActivation, wake: () => void): void {
-  const child = activation.handle.agent;
-  child.ctx.on("agent/error", ({ agent }) => {
-    if (agent !== child) return;
-    activation.failureAt = child.session.seq;
-    wake();
-  });
-  child.ctx.on("session/event", (session, event) => {
-    if (
-      session === child.session &&
-      event.type === "turn/end" &&
-      activation.failureAt !== undefined &&
-      event.seq >= activation.failureAt
-    ) {
-      activation.failureAt = undefined;
+  const child = activation.handle.agent
+  child.ctx.on('agent/error', ({ agent }) => {
+    if (agent !== child) return
+    activation.failureAt = child.session.seq
+    wake()
+  })
+  child.ctx.on('session/event', (session, event) => {
+    if (session === child.session && event.type === 'turn/end'
+      && activation.failureAt !== undefined && event.seq >= activation.failureAt) {
+      activation.failureAt = undefined
     }
-  });
+  })
 }
 
 /**
@@ -160,21 +155,21 @@ export function observeLocalFailure(activation: LocalActivation, wake: () => voi
  */
 export function captureLocalResult(activation: LocalActivation): SubagentResult {
   // oxlint-disable-next-line typescript/no-deprecated -- Existing Session history read; migration deferred.
-  const events = activation.handle.agent.session.snapshotEvents(activation.outputStart);
-  const output = finalAssistantOutput(events) ?? [];
-  const stopReason = activation.failureAt === undefined ? epochStopReason(events) : "error";
-  const structured = activation.structured;
+  const events = activation.handle.agent.session.snapshotEvents(activation.outputStart)
+  const output = finalAssistantOutput(events) ?? []
+  const stopReason = activation.failureAt === undefined ? epochStopReason(events) : 'error'
+  const structured = activation.structured
   if (structured !== undefined) {
-    const captured = structured.captured();
-    if (captured !== undefined) return { output, stopReason, structured: captured.value };
-    if (stopReason === "completed") return { output, stopReason: "error" };
+    const captured = structured.captured()
+    if (captured !== undefined) return { output, stopReason, structured: captured.value }
+    if (stopReason === 'completed') return { output, stopReason: 'error' }
   }
-  return { output, stopReason };
+  return { output, stopReason }
 }
 
 /** Serialize each durable child's delivery, release, and disposal. */
 export class ChildLock {
-  private tails = new Map<SessionId, Promise<unknown>>();
+  private tails = new Map<SessionId, Promise<unknown>>()
 
   /**
    * Run `operation` after every previously queued operation for `childId`.
@@ -183,18 +178,15 @@ export class ChildLock {
    * @returns the operation's own settlement.
    */
   run<T>(childId: SessionId, operation: () => Promise<T>): Promise<T> {
-    const previous = this.tails.get(childId) ?? Promise.resolve();
-    const result = previous.then(operation, operation);
+    const previous = this.tails.get(childId) ?? Promise.resolve()
+    const result = previous.then(operation, operation)
     // Absorb rejections in the chaining tail so one failed critical section
     // cannot reject an unrelated later caller.
-    const tail = result.then(
-      () => undefined,
-      () => undefined,
-    );
-    this.tails.set(childId, tail);
+    const tail = result.then(() => undefined, () => undefined)
+    this.tails.set(childId, tail)
     void tail.then(() => {
-      if (this.tails.get(childId) === tail) this.tails.delete(childId);
-    });
-    return result;
+      if (this.tails.get(childId) === tail) this.tails.delete(childId)
+    })
+    return result
   }
 }

package/src/vendor/dsh-subagent/archive-admission.ts

@@ -6,12 +6,12 @@
  * @module @deepseek-ai/dsh-subagent
  */
 
-import type { Context } from "@deepseek-ai/cordis";
-import type { Agent } from "@deepseek-ai/dsh-agent";
-import type { SessionId } from "@deepseek-ai/dsh-session";
-import type {} from "@deepseek-ai/dsh-session-query";
-import type { SessionActivity, SessionActivityItem } from "@deepseek-ai/dsh-workspace";
-import { foldSubagentDescriptor } from "./descriptor.ts";
+import type { Context } from '@deepseek-ai/cordis'
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import type { SessionId } from '@deepseek-ai/dsh-session'
+import type {} from '@deepseek-ai/dsh-session-query'
+import type { SessionActivity, SessionActivityItem } from '@deepseek-ai/dsh-workspace'
+import { foldSubagentDescriptor } from './descriptor.ts'
 
 /**
  * Answer `workspace/session-activity` with the running subagent descendants of
@@ -20,28 +20,23 @@ import { foldSubagentDescriptor } from "./descriptor.ts";
  * @param ctx - context carrying the Agent registry; the Session query service is optional and only supplies labels.
  */
 export function installSubagentArchiveAdmission(ctx: Context): void {
-  ctx.on("workspace/session-activity", async ({ sessionId }, next) => {
-    const running = runningDescendants(ctx, sessionId);
-    const rest = await next();
-    if (running.length === 0) return rest;
-    const own: SessionActivity = {
-      kind: "subagent",
-      items: await Promise.all(running.map((child) => describe(ctx, child))),
-    };
-    return [own, ...rest];
-  });
-  ctx.on("workspace/session-stop", ({ sessionId }) => {
+  ctx.on('workspace/session-activity', async ({ sessionId }, next) => {
+    const running = runningDescendants(ctx, sessionId)
+    const rest = await next()
+    if (running.length === 0) return rest
+    const own: SessionActivity = { kind: 'subagent', items: await Promise.all(running.map(child => describe(ctx, child))) }
+    return [own, ...rest]
+  })
+  ctx.on('workspace/session-stop', ({ sessionId }) => {
     for (const child of runningDescendants(ctx, sessionId)) {
       try {
-        child.cancel({ kind: "parent" });
+        child.cancel({ kind: 'parent' })
       } catch (error: unknown) {
         // One child refusing its cancel must not keep its siblings running for an archived parent.
-        ctx.logger.warn(
-          `subagent: cancelling "${child.id}" for an archived Session failed: ${String(error)}`,
-        );
+        ctx.logger.warn(`subagent: cancelling "${child.id}" for an archived Session failed: ${String(error)}`)
       }
     }
-  });
+  })
 }
 
 /**
@@ -52,27 +47,27 @@ export function installSubagentArchiveAdmission(ctx: Context): void {
  * is read as data, so a damaged header chain that loops is visited once.
  */
 function runningDescendants(ctx: Context, rootId: SessionId): Agent[] {
-  const childrenOf = new Map<SessionId, Agent[]>();
+  const childrenOf = new Map<SessionId, Agent[]>()
   for (const agent of ctx.agents.list()) {
-    const { parentSession, origin } = agent.session.header;
-    if (parentSession === undefined || origin !== "subagent") continue;
-    const siblings = childrenOf.get(parentSession) ?? [];
-    siblings.push(agent);
-    childrenOf.set(parentSession, siblings);
+    const { parentSession, origin } = agent.session.header
+    if (parentSession === undefined || origin !== 'subagent') continue
+    const siblings = childrenOf.get(parentSession) ?? []
+    siblings.push(agent)
+    childrenOf.set(parentSession, siblings)
   }
-  const running: Agent[] = [];
-  const pending = [rootId];
-  const visited = new Set<SessionId>();
+  const running: Agent[] = []
+  const pending = [rootId]
+  const visited = new Set<SessionId>()
   while (pending.length > 0) {
-    const parentId = pending.shift() as SessionId;
-    if (visited.has(parentId)) continue;
-    visited.add(parentId);
+    const parentId = pending.shift() as SessionId
+    if (visited.has(parentId)) continue
+    visited.add(parentId)
     for (const child of childrenOf.get(parentId) ?? []) {
-      if (child.status === "running") running.push(child);
-      pending.push(child.id);
+      if (child.status === 'running') running.push(child)
+      pending.push(child.id)
     }
   }
-  return running;
+  return running
 }
 
 /**
@@ -82,16 +77,14 @@ function runningDescendants(ctx: Context, rootId: SessionId): Agent[] {
  * the item names the child by id alone.
  */
 async function describe(ctx: Context, child: Agent): Promise<SessionActivityItem> {
-  const query = ctx.get("sessionQuery");
-  if (query === undefined) return { id: child.id };
+  const query = ctx.get('sessionQuery')
+  if (query === undefined) return { id: child.id }
   try {
-    using observation = await query.observeSession(child.id, { projectionMode: "none" });
-    const label = foldSubagentDescriptor(
-      observation.events.slice(observation.inheritedEventCount),
-    )?.label;
-    return label === undefined ? { id: child.id } : { id: child.id, label };
+    using observation = await query.observeSession(child.id, { projectionMode: 'none' })
+    const label = foldSubagentDescriptor(observation.events.slice(observation.inheritedEventCount))?.label
+    return label === undefined ? { id: child.id } : { id: child.id, label }
   } catch {
     // A damaged descriptor is data damage in the child; the report still names the child.
-    return { id: child.id };
+    return { id: child.id }
   }
 }

package/src/vendor/dsh-subagent/assistant-output.ts

@@ -10,8 +10,8 @@
  * @module @deepseek-ai/dsh-subagent/assistant-output
  */
 
-import { joinAssistantStreamText, type ContentBlock } from "@deepseek-ai/dsh-llm";
-import type { SessionEvent } from "@deepseek-ai/dsh-session";
+import { joinAssistantStreamText, type ContentBlock } from '@deepseek-ai/dsh-llm'
+import type { SessionEvent } from '@deepseek-ai/dsh-session'
 
 /**
  * Incremental fold of the selection rule, for backends that observe a child's
@@ -20,8 +20,8 @@ import type { SessionEvent } from "@deepseek-ai/dsh-session";
  * text into the same streamed fallback.
  */
 export class AssistantOutputFold {
-  private message: readonly ContentBlock[] | undefined;
-  private partial: string[] = [];
+  private message: readonly ContentBlock[] | undefined
+  private partial: string[] = []
 
   /**
    * Fold one session event: a non-empty assistant message becomes the
@@ -30,12 +30,12 @@ export class AssistantOutputFold {
    * @param event - the next observed session event.
    */
   push(event: SessionEvent): void {
-    if (event.type === "assistant/message") {
-      const content = event.data.message.content;
-      if (content.length > 0) this.message = content;
+    if (event.type === 'assistant/message') {
+      const content = event.data.message.content
+      if (content.length > 0) this.message = content
     }
-    if (event.type === "assistant/message" || event.type === "assistant/attempt") {
-      this.pushText(joinAssistantStreamText(event.data.stream));
+    if (event.type === 'assistant/message' || event.type === 'assistant/attempt') {
+      this.pushText(joinAssistantStreamText(event.data.stream))
     }
   }
 
@@ -44,7 +44,7 @@ export class AssistantOutputFold {
    * @param text - the next streamed text piece (an empty piece is a no-op).
    */
   pushText(text: string): void {
-    if (text.length > 0) this.partial.push(text);
+    if (text.length > 0) this.partial.push(text)
   }
 
   /**
@@ -53,9 +53,9 @@ export class AssistantOutputFold {
    *   streamed text, or `undefined` when the child produced neither.
    */
   collect(): readonly ContentBlock[] | undefined {
-    if (this.message !== undefined) return this.message;
-    const text = this.partial.join("");
-    return text.length > 0 ? [{ type: "text", text }] : undefined;
+    if (this.message !== undefined) return this.message
+    const text = this.partial.join('')
+    return text.length > 0 ? [{ type: 'text', text }] : undefined
   }
 }
 
@@ -64,14 +64,12 @@ export class AssistantOutputFold {
  * @param events - the child-owned events (after any seed or epoch boundary).
  * @returns the selected output, or `undefined` when the child produced none.
  */
-export function finalAssistantOutput(
-  events: readonly SessionEvent[],
-): readonly ContentBlock[] | undefined {
+export function finalAssistantOutput(events: readonly SessionEvent[]): readonly ContentBlock[] | undefined {
   // TODO: this folds the complete suffix once per run/epoch settlement. If a
   // long continuable epoch ever profiles hot here, scan backward with early
   // exit for the last non-empty message and fold text deltas only on the
   // no-message fallback.
-  const fold = new AssistantOutputFold();
-  for (const event of events) fold.push(event);
-  return fold.collect();
+  const fold = new AssistantOutputFold()
+  for (const event of events) fold.push(event)
+  return fold.collect()
 }