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

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

@@ -4,15 +4,15 @@
  * @module @deepseek-ai/dsh-subagent/internal
  */
 
-import type { Agent } from "@deepseek-ai/dsh-agent";
-import type { ContentBlock, MessageId, MessageSource } from "@deepseek-ai/dsh-llm";
-import type { SessionId } from "@deepseek-ai/dsh-session";
-import type { ToolDefinition } from "@deepseek-ai/dsh-tools";
-import type SubagentRuntime from "./index.ts";
-import type { SubagentDelivery } from "./control-types.ts";
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import type { ContentBlock, MessageId, MessageSource } from '@deepseek-ai/dsh-llm'
+import type { SessionId } from '@deepseek-ai/dsh-session'
+import type { ToolDefinition } from '@deepseek-ai/dsh-tools'
+import type SubagentRuntime from './index.ts'
+import type { SubagentDelivery } from './control-types.ts'
 
 /** Process-stable identity carried only by the standard adjacent-Agent messaging tool. */
-export const adjacentAgentSendMessageTool = Symbol.for("dsh.subagent.adjacentAgentSendMessageTool");
+export const adjacentAgentSendMessageTool = Symbol.for('dsh.subagent.adjacentAgentSendMessageTool')
 
 /**
  * Mark the standard adjacent-Agent messaging tool without changing its model-visible schema.
@@ -20,8 +20,8 @@ export const adjacentAgentSendMessageTool = Symbol.for("dsh.subagent.adjacentAge
  * @returns the same definition with its internal identity installed.
  */
 export function markAdjacentAgentSendMessageTool(definition: ToolDefinition): ToolDefinition {
-  Object.defineProperty(definition, adjacentAgentSendMessageTool, { value: true });
-  return definition;
+  Object.defineProperty(definition, adjacentAgentSendMessageTool, { value: true })
+  return definition
 }
 
 /**
@@ -30,12 +30,8 @@ export function markAdjacentAgentSendMessageTool(definition: ToolDefinition): To
  * @returns whether the definition carries the internal standard-tool identity.
  */
 export function isAdjacentAgentSendMessageTool(definition: ToolDefinition | undefined): boolean {
-  return (
-    definition !== undefined &&
-    (definition as ToolDefinition & { [adjacentAgentSendMessageTool]?: true })[
-      adjacentAgentSendMessageTool
-    ] === true
-  );
+  return definition !== undefined
+    && (definition as ToolDefinition & { [adjacentAgentSendMessageTool]?: true })[adjacentAgentSendMessageTool] === true
 }
 
 /**
@@ -43,7 +39,7 @@ export function isAdjacentAgentSendMessageTool(definition: ToolDefinition | unde
  * entry and this unbundled internal subpath.
  * @internal
  */
-export const deliverSubagentPrompt = Symbol.for("dsh.subagent.deliverPrompt");
+export const deliverSubagentPrompt = Symbol.for('dsh.subagent.deliverPrompt')
 
 /** Runtime face required by the host-only prompt adapters. */
 export interface HostPromptDeliverer {
@@ -54,7 +50,7 @@ export interface HostPromptDeliverer {
     source: MessageSource,
     signal: AbortSignal,
     delivery: SubagentDelivery,
-  ): Promise<MessageId>;
+  ): Promise<MessageId>
 }
 
 /**
@@ -81,8 +77,8 @@ export function queueHostSubagentPrompt(
     content,
     source,
     signal,
-    "queue",
-  );
+    'queue',
+  )
 }
 
 /**
@@ -109,6 +105,6 @@ export function steerHostSubagentPrompt(
     content,
     source,
     signal,
-    "steer",
-  );
+    'steer',
+  )
 }

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

@@ -7,13 +7,13 @@
  * @module @deepseek-ai/dsh-subagent/lifecycle
  */
 
-import { randomUUID } from "node:crypto";
-import type { Context } from "@deepseek-ai/cordis";
-import type { Agent } from "@deepseek-ai/dsh-agent";
-import { foldConsumedWork } from "@deepseek-ai/dsh-agent";
-import type { SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
-import { SubagentRunId } from "./types.ts";
-import type { SubagentResult, SubagentRunEndInfo, SubagentRunInfo } from "./types.ts";
+import { randomUUID } from 'node:crypto'
+import type { Context } from '@deepseek-ai/cordis'
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import { foldConsumedWork } from '@deepseek-ai/dsh-agent'
+import type { SessionEvent, SessionId } from '@deepseek-ai/dsh-session'
+import { SubagentRunId } from './types.ts'
+import type { SubagentResult, SubagentRunEndInfo, SubagentRunInfo } from './types.ts'
 
 /**
  * Lifecycle observer for one activation's residency epoch. Package-private: the
@@ -25,7 +25,7 @@ export interface ActivationObserver {
    * Publish the start edge once the epoch is resident.
    * @param child - the resident local Agent, or undefined for an external execution.
    */
-  start(child?: Agent): void;
+  start(child?: Agent): void
   /**
    * Publish the terminal edge exactly once, pairing this epoch's {@link start},
    * after the disposal outcome is known. Called only for a resident epoch: a
@@ -33,7 +33,7 @@ export interface ActivationObserver {
    * report a lifecycle the child never had.
    * @param result - the captured result, with teardown failures applied.
    */
-  settle(result: SubagentResult): void;
+  settle(result: SubagentResult): void
 }
 
 /**
@@ -46,10 +46,10 @@ export interface ActivationObserver {
  * a narrowed stand-in would silently change scope filtering.
  */
 export type LifecycleEmitter = {
-  (name: "subagent/start", info: SubagentRunInfo, parent: Agent): void;
-  (name: "subagent/end", info: SubagentRunEndInfo, parent: Agent): void;
-  (name: "subagent/provider-removed", info: string): void;
-};
+  (name: 'subagent/start', info: SubagentRunInfo, parent: Agent): void
+  (name: 'subagent/end', info: SubagentRunEndInfo, parent: Agent): void
+  (name: 'subagent/provider-removed', info: string): void
+}
 
 /**
  * Build the contained lifecycle emitter this seam publishes every edge through.
@@ -65,23 +65,24 @@ export function createLifecycleEmitter(
   carrier: (parent: Agent) => object,
 ): LifecycleEmitter {
   return (
-    name: "subagent/start" | "subagent/end" | "subagent/provider-removed",
+    name: 'subagent/start' | 'subagent/end' | 'subagent/provider-removed',
     info: SubagentRunInfo | SubagentRunEndInfo | string,
     parent?: Agent,
   ): void => {
-    const dispatchArgs: unknown[] =
-      parent === undefined ? [name, info] : [carrier(parent), name, info];
-    for (const callback of ctx.events.dispatch("emit", dispatchArgs)) {
+    const dispatchArgs: unknown[] = parent === undefined
+      ? [name, info]
+      : [carrier(parent), name, info]
+    for (const callback of ctx.events.dispatch('emit', dispatchArgs)) {
       try {
-        const returned: unknown = callback(info);
+        const returned: unknown = callback(info)
         void Promise.resolve(returned).catch((error: unknown) => {
-          ctx.logger.warn(`subagent: ${name} listener rejected: ${renderThrown(error)}`);
-        });
+          ctx.logger.warn(`subagent: ${name} listener rejected: ${renderThrown(error)}`)
+        })
       } catch (error: unknown) {
-        ctx.logger.warn(`subagent: ${name} listener threw: ${renderThrown(error)}`);
+        ctx.logger.warn(`subagent: ${name} listener threw: ${renderThrown(error)}`)
       }
     }
-  };
+  }
 }
 
 /**
@@ -98,24 +99,20 @@ export function createActivationObserver(
   childId: SessionId,
   parent: Agent,
 ): ActivationObserver {
-  const identity = { runId: SubagentRunId(randomUUID()), provider, id: childId, local: false };
+  const identity = { runId: SubagentRunId(randomUUID()), provider, id: childId, local: false }
   return {
     start: (child?: Agent): void => {
-      identity.local = child !== undefined;
-      emit("subagent/start", identity, parent);
+      identity.local = child !== undefined
+      emit('subagent/start', identity, parent)
     },
     settle: ({ stopReason, output }: SubagentResult): void => {
-      emit(
-        "subagent/end",
-        {
-          ...identity,
-          stopReason,
-          ...(output.length === 0 ? {} : { lastAssistantMessage: output }),
-        },
-        parent,
-      );
+      emit('subagent/end', {
+        ...identity,
+        stopReason,
+        ...output.length === 0 ? {} : { lastAssistantMessage: output },
+      }, parent)
     },
-  };
+  }
 }
 
 /**
@@ -134,39 +131,39 @@ export function createActivationObserver(
  * @returns its terminal stop reason; `completed` only for an epoch that both
  *   closed cleanly and had nothing left to run.
  */
-export function epochStopReason(events: readonly SessionEvent[]): SubagentResult["stopReason"] {
-  const { end, droppedUnrun } = foldConsumedWork(events);
+export function epochStopReason(events: readonly SessionEvent[]): SubagentResult['stopReason'] {
+  const { end, droppedUnrun } = foldConsumedWork(events)
   switch (end?.data.reason.kind) {
-    case "max-tokens":
-      return "max-tokens";
-    case "aborted":
-    case "interrupted":
-      return "aborted";
-    case "error":
-      return "error";
+    case 'max-tokens':
+      return 'max-tokens'
+    case 'aborted':
+    case 'interrupted':
+      return 'aborted'
+    case 'error':
+      return 'error'
     // A pre-step rejection — a hook deny, a policy plugin — discarded input
     // this epoch had claimed: the work was declined, not done.
-    case "blocked":
-      return "refusal";
+    case 'blocked':
+      return 'refusal'
     // A clean ending and no accounting turn at all share one rule: the epoch
     // finished what it was given unless a cancelled queue says otherwise.
     case undefined:
-    case "completed":
-      return droppedUnrun ? "aborted" : "completed";
+    case 'completed':
+      return droppedUnrun ? 'aborted' : 'completed'
     /* v8 ignore next 4 -- `forked` appears only in constructor seed history, while
      * this function reads an epoch-owned suffix. `TurnEndReason` is merge-extensible,
      * so a backend-added variant cannot be listed; treating an unnameable reason as
      * success would report failed work as completed. */
     default:
-      return "error";
+      return 'error'
   }
 }
 
 /** Render any listener-thrown value without letting coercion escape containment. */
 function renderThrown(value: unknown): string {
   try {
-    return value instanceof Error ? `${value.name}: ${value.message}` : String(value);
+    return value instanceof Error ? `${value.name}: ${value.message}` : String(value)
   } catch {
-    return "<unrenderable thrown value>";
+    return '<unrenderable thrown value>'
   }
 }

package/src/vendor/dsh-subagent/list-children.ts

@@ -4,21 +4,21 @@
  * @module @deepseek-ai/dsh-subagent
  */
 
-import type { Context } from "@deepseek-ai/cordis";
-import type { SessionId } from "@deepseek-ai/dsh-session";
-import type { SubagentListEntry } from "./control-types.ts";
-import { SubagentError } from "./error.ts";
-import type { SubagentCatalogEntry } from "./projection-types.ts";
+import type { Context } from '@deepseek-ai/cordis'
+import type { SessionId } from '@deepseek-ai/dsh-session'
+import type { SubagentListEntry } from './control-types.ts'
+import { SubagentError } from './error.ts'
+import type { SubagentCatalogEntry } from './projection-types.ts'
 
-export type { SubagentListEntry } from "./control-types.ts";
+export type { SubagentListEntry } from './control-types.ts'
 
 /** One catalog descendant with its direct parent and edge distance from the requested root. */
 export type SubagentDescendantListEntry = SubagentListEntry & {
   /** Parent whose catalog contains this child. */
-  readonly parentId: SessionId;
+  readonly parentId: SessionId
   /** Edge distance from the requested root; direct children are `1`. */
-  readonly depth: number;
-};
+  readonly depth: number
+}
 
 /**
  * Read one parent's durable catalog through a live-preferred Session observation.
@@ -33,24 +33,24 @@ export async function listChildren(
   parentSessionId: SessionId,
   signal?: AbortSignal,
 ): Promise<SubagentCatalogEntry[]> {
-  const query = ctx.get("sessionQuery");
+  const query = ctx.get('sessionQuery')
   if (query === undefined) {
     throw new SubagentError(
-      "listing subagents requires the sessionQuery service (load @deepseek-ai/dsh-session-query)",
-      "SUBAGENT_CONTROL_QUERY_UNAVAILABLE",
-    );
+      'listing subagents requires the sessionQuery service (load @deepseek-ai/dsh-session-query)',
+      'SUBAGENT_CONTROL_QUERY_UNAVAILABLE',
+    )
   }
   using parent = await query.observeSession(parentSessionId, {
-    ...(signal === undefined ? {} : { signal }),
-  });
-  const entries = parent.projections?.values.subagentCatalog;
+    ...signal === undefined ? {} : { signal },
+  })
+  const entries = parent.projections?.values.subagentCatalog
   if (entries === undefined) {
     throw new SubagentError(
-      "listing subagents requires the registered subagentCatalog projection",
-      "SUBAGENT_CONTROL_PROJECTIONS_UNAVAILABLE",
-    );
+      'listing subagents requires the registered subagentCatalog projection',
+      'SUBAGENT_CONTROL_PROJECTIONS_UNAVAILABLE',
+    )
   }
-  return entries;
+  return entries
 }
 
 /**
@@ -66,76 +66,68 @@ export async function listDescendants(
   rootSessionId: SessionId,
   signal?: AbortSignal,
 ): Promise<SubagentDescendantListEntry[]> {
-  const sessions = ctx.get("sessions");
+  const sessions = ctx.get('sessions')
   if (sessions === undefined) {
     throw new SubagentError(
-      "listing subagents requires the session store (load @deepseek-ai/dsh-session)",
-      "SUBAGENT_CONTROL_SESSION_STORE_UNAVAILABLE",
-    );
+      'listing subagents requires the session store (load @deepseek-ai/dsh-session)',
+      'SUBAGENT_CONTROL_SESSION_STORE_UNAVAILABLE',
+    )
   }
   const readChildren = async (id: SessionId): Promise<SubagentCatalogEntry[]> => {
-    assertListingNotCancelled(signal);
-    let children: SubagentCatalogEntry[];
+    assertListingNotCancelled(signal)
+    let children: SubagentCatalogEntry[]
     try {
-      children = await listChildren(ctx, id, signal);
+      children = await listChildren(ctx, id, signal)
     } catch (error) {
-      assertListingNotCancelled(signal);
-      throw error;
+      assertListingNotCancelled(signal)
+      throw error
     }
-    assertListingNotCancelled(signal);
-    return children;
-  };
+    assertListingNotCancelled(signal)
+    return children
+  }
   const stack = (await readChildren(rootSessionId))
-    .map((entry) => ({ entry, parentId: rootSessionId, depth: 1 }))
-    .reverse();
-  const visited = new Set<SessionId>([rootSessionId]);
-  const result: SubagentDescendantListEntry[] = [];
+    .map(entry => ({ entry, parentId: rootSessionId, depth: 1 }))
+    .reverse()
+  const visited = new Set<SessionId>([rootSessionId])
+  const result: SubagentDescendantListEntry[] = []
   for (let position = stack.pop(); position !== undefined; position = stack.pop()) {
-    const { entry, parentId, depth } = position;
-    if (visited.has(entry.id)) continue;
-    visited.add(entry.id);
-    let children: SubagentCatalogEntry[];
+    const { entry, parentId, depth } = position
+    if (visited.has(entry.id)) continue
+    visited.add(entry.id)
+    let children: SubagentCatalogEntry[]
     try {
-      children = entry.mode === "external" ? [] : await readChildren(entry.id);
+      children = entry.mode === 'external' ? [] : await readChildren(entry.id)
     } catch (error) {
-      if (error instanceof SubagentError) throw error;
-      const code = error instanceof Error && "code" in error ? error.code : undefined;
+      if (error instanceof SubagentError) throw error
+      const code = error instanceof Error && 'code' in error ? error.code : undefined
       result.push({
-        kind: "diagnostic",
-        id: entry.id,
-        parentId,
-        depth,
-        reason:
-          code === "SESSION_QUERY_CORRUPT_SESSION" || code === "SESSION_QUERY_SOURCE_CONFLICT"
-            ? "corrupt"
-            : "unavailable",
-      });
-      continue;
+        kind: 'diagnostic', id: entry.id, parentId, depth,
+        reason: code === 'SESSION_QUERY_CORRUPT_SESSION' || code === 'SESSION_QUERY_SOURCE_CONFLICT'
+          ? 'corrupt' : 'unavailable',
+      })
+      continue
     }
-    if (entry.mode === "unknown") {
-      result.push({ kind: "diagnostic", id: entry.id, parentId, depth, reason: "unsupported" });
+    if (entry.mode === 'unknown') {
+      result.push({ kind: 'diagnostic', id: entry.id, parentId, depth, reason: 'unsupported' })
     } else {
-      const { createdAt: _createdAt, ...identity } = entry;
+      const { createdAt: _createdAt, ...identity } = entry
       result.push({
-        ...identity,
-        kind: "child",
-        parentId,
-        depth,
-        activity: sessions.get(entry.id) === undefined ? "inactive" : "running",
+        ...identity, kind: 'child', parentId, depth,
+        activity: sessions.get(entry.id) === undefined ? 'inactive' : 'running',
         hasChildren: children.length > 0,
-      });
+      })
     }
     // Catalog event order defines siblings; the stack visits the first one next.
     for (const child of [...children].reverse()) {
-      stack.push({ entry: child, parentId: entry.id, depth: depth + 1 });
+      stack.push({ entry: child, parentId: entry.id, depth: depth + 1 })
     }
   }
-  return result;
+  return result
 }
 
 /** Stop the complete traversal when its caller cancels. */
 function assertListingNotCancelled(signal: AbortSignal | undefined): void {
   if (signal?.aborted) {
-    throw new SubagentError("subagent listing was cancelled", "CANCELLED");
+    throw new SubagentError('subagent listing was cancelled', 'CANCELLED')
   }
 }