@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/slash/prompt-template-bridge.js

@@ -1,288 +1,339 @@
-export const PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT = "prompt-template:subagent:request";
-export const PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT = "prompt-template:subagent:started";
-export const PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT = "prompt-template:subagent:response";
-export const PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT = "prompt-template:subagent:update";
-export const PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT = "prompt-template:subagent:cancel";
-function parseDelegationTasks(tasks) {
-  if (!Array.isArray(tasks))
-    return [];
-  const parsed = [];
-  for (const item of tasks) {
-    if (!item || typeof item !== "object")
-      return [];
-    const value = item;
-    if (typeof value.agent !== "string" || !value.agent.trim())
-      return [];
-    if (typeof value.task !== "string" || !value.task.trim())
-      return [];
-    const model = typeof value.model === "string" && value.model.trim().length > 0 ? value.model : undefined;
-    const cwd = typeof value.cwd === "string" && value.cwd.trim().length > 0 ? value.cwd : undefined;
-    parsed.push({
-      agent: value.agent,
-      task: value.task,
-      ...model ? { model } : {},
-      ...cwd ? { cwd } : {}
-    });
-  }
-  return parsed;
-}
-function parsePromptTemplateRequest(data) {
-  if (!data || typeof data !== "object")
-    return;
+import {
+  SUBAGENT_DELEGATION_CANCEL_EVENT,
+  SUBAGENT_DELEGATION_REQUEST_EVENT,
+  SUBAGENT_DELEGATION_RESPONSE_EVENT,
+  SUBAGENT_DELEGATION_STARTED_EVENT,
+  SUBAGENT_DELEGATION_UPDATE_EVENT
+} from "../api/delegation.js";
+import { parseSubagentDelegationRequest } from "./delegation-request.js";
+import {
+  parsePromptTemplateRequest,
+  toDelegationUpdate,
+  toPromptTemplateResponse,
+  toSubagentDelegationExecutionParams,
+  toSubagentDelegationResponse,
+  toSubagentDelegationUpdate
+} from "./delegation-adapters.js";
+export const PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT = SUBAGENT_DELEGATION_REQUEST_EVENT;
+export const PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT = SUBAGENT_DELEGATION_STARTED_EVENT;
+export const PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT = SUBAGENT_DELEGATION_RESPONSE_EVENT;
+export const PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT = SUBAGENT_DELEGATION_UPDATE_EVENT;
+export const PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT = SUBAGENT_DELEGATION_CANCEL_EVENT;
+function hasStructuredDelegationMarker(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data))
+    return false;
   const value = data;
-  if (typeof value.requestId !== "string" || !value.requestId)
-    return;
-  if (typeof value.model !== "string" || !value.model)
-    return;
-  if (typeof value.cwd !== "string" || !value.cwd)
-    return;
-  if (value.context !== "fresh" && value.context !== "fork")
-    return;
-  const tasks = parseDelegationTasks(value.tasks);
-  const worktree = value.worktree === true ? true : undefined;
-  const hasSingle = typeof value.agent === "string" && value.agent.length > 0 && typeof value.task === "string" && value.task.length > 0;
-  if (!hasSingle && tasks.length === 0)
-    return;
-  const fallbackTask = tasks[0];
-  return {
-    requestId: value.requestId,
-    agent: hasSingle ? value.agent : fallbackTask.agent,
-    task: hasSingle ? value.task : fallbackTask.task,
-    ...tasks.length > 0 ? { tasks } : {},
-    context: value.context,
-    model: value.model,
-    cwd: value.cwd,
-    ...worktree ? { worktree } : {}
-  };
+  return Object.hasOwn(value, "ownerRunId") || Object.hasOwn(value, "nodeId") || Object.hasOwn(value, "result") || Object.hasOwn(value, "version");
 }
-function firstTextContent(content) {
-  if (!Array.isArray(content))
-    return;
-  for (const part of content) {
-    if (!part || typeof part !== "object")
-      continue;
-    if (part.type !== "text")
-      continue;
-    const text = part.text;
-    if (typeof text === "string" && text.trim())
-      return text.trim();
-  }
-  return;
-}
-function filterRecentOutput(lines) {
-  if (!lines || lines.length === 0)
-    return;
-  const filtered = lines.filter((line) => typeof line === "string" && line.trim() && line.trim() !== "(running...)");
-  if (filtered.length === 0)
-    return;
-  return filtered;
-}
-function sanitizeRecentTools(tools) {
-  if (!tools || tools.length === 0)
-    return;
-  const sanitized = tools.flatMap((entry) => {
-    if (typeof entry.tool !== "string" || entry.tool.trim().length === 0)
-      return [];
-    return [{
-      tool: entry.tool,
-      args: typeof entry.args === "string" ? entry.args : String(entry.args ?? "")
-    }];
-  });
-  return sanitized.length > 0 ? sanitized : undefined;
-}
-function resolveProgressModel(update, entry) {
-  const results = update.details?.results;
-  if (!results || results.length === 0)
-    return;
-  if (typeof entry.index === "number" && entry.index >= 0) {
-    const byIndex = results[entry.index];
-    if (typeof byIndex?.model === "string")
-      return byIndex.model;
-  }
-  if (entry.agent) {
-    const byAgent = results.find((result) => result.agent === entry.agent && typeof result.model === "string");
-    if (byAgent?.model)
-      return byAgent.model;
-  }
-  const firstWithModel = results.find((result) => typeof result.model === "string");
-  return firstWithModel?.model;
-}
-function toolCallNameFromSummary(summary) {
-  const text = typeof summary.expandedText === "string" && summary.expandedText.trim().length > 0 ? summary.expandedText.trim() : typeof summary.text === "string" ? summary.text.trim() : "";
-  if (!text)
-    return;
-  if (text.startsWith("$ "))
-    return "bash";
-  return text.match(/^[A-Za-z_][\w.-]*/)?.[0];
-}
-function buildDelegationMessages(result, fallbackText) {
-  if (Array.isArray(result.messages) && result.messages.length > 0)
-    return result.messages;
-  const toolCallParts = (result.toolCalls ?? []).flatMap((summary) => {
-    const name = toolCallNameFromSummary(summary);
-    return name ? [{ type: "toolCall", name, arguments: { summary: summary.expandedText ?? summary.text ?? "" } }] : [];
-  });
-  const text = typeof result.finalOutput === "string" && result.finalOutput.trim().length > 0 ? result.finalOutput.trim() : fallbackText;
-  const content = [
-    ...toolCallParts,
-    ...text ? [{ type: "text", text }] : []
-  ];
-  if (content.length === 0)
-    return [];
-  return [{ role: "assistant", content }];
-}
-function toDelegationUpdate(requestId, update) {
-  const progress = update.details?.progress?.[0];
-  const taskProgress = update.details?.progress?.map((entry) => {
-    const lastOutput = entry.recentOutput?.[entry.recentOutput.length - 1];
-    const safeLastOutput = typeof lastOutput === "string" && lastOutput.trim() && lastOutput !== "(running...)" ? lastOutput : undefined;
-    return {
-      index: entry.index,
-      agent: entry.agent ?? "delegate",
-      status: entry.status,
-      currentTool: entry.currentTool,
-      currentToolArgs: entry.currentToolArgs,
-      recentOutput: safeLastOutput,
-      recentOutputLines: filterRecentOutput(entry.recentOutput),
-      recentTools: sanitizeRecentTools(entry.recentTools),
-      model: resolveProgressModel(update, entry),
-      toolCount: entry.toolCount,
-      durationMs: entry.durationMs,
-      tokens: entry.tokens
-    };
-  });
-  if (!progress && (!taskProgress || taskProgress.length === 0))
-    return;
-  const lastOutput = progress?.recentOutput?.[progress.recentOutput.length - 1];
-  const safeLastOutput = typeof lastOutput === "string" && lastOutput.trim() && lastOutput !== "(running...)" ? lastOutput : undefined;
-  return {
-    requestId,
-    currentTool: progress?.currentTool,
-    currentToolArgs: progress?.currentToolArgs,
-    recentOutput: safeLastOutput,
-    recentOutputLines: filterRecentOutput(progress?.recentOutput),
-    recentTools: sanitizeRecentTools(progress?.recentTools),
-    model: progress ? resolveProgressModel(update, progress) : undefined,
-    toolCount: progress?.toolCount,
-    durationMs: progress?.durationMs,
-    tokens: progress?.tokens,
-    taskProgress
-  };
+function validId(value) {
+  return typeof value === "string" && value.trim().length > 0 && value.length <= 256 && !/[\r\n]/.test(value);
 }
 export function registerPromptTemplateDelegationBridge(options) {
-  const controllers = new Map;
-  const pendingCancels = new Set;
+  const legacyControllers = new Map;
+  const pendingLegacyCancels = new Map;
+  const attemptControllers = new Map;
+  const pendingAttemptCancels = new Map;
+  const activeOwnedNodes = new Map;
+  const settledAttempts = new Map;
   const subscriptions = [];
+  let disposed = false;
+  let identitySaturated = false;
   const subscribe = (event, handler) => {
     const unsubscribe = options.events.on(event, handler);
     if (typeof unsubscribe === "function")
       subscriptions.push(unsubscribe);
   };
+  const ownsLegacyRequest = (requestId, controller) => !disposed && legacyControllers.get(requestId) === controller;
+  const ownsAttempt = (attemptKey, controller) => !disposed && attemptControllers.get(attemptKey) === controller;
+  const boundedRemember = (map, key) => {
+    map.delete(key);
+    map.set(key, true);
+    while (map.size > 256) {
+      const oldest = map.keys().next().value;
+      if (typeof oldest !== "string")
+        break;
+      map.delete(oldest);
+    }
+  };
+  const rememberIdentity = (map, key) => {
+    if (map.has(key) || identitySaturated)
+      return;
+    if (map.size >= 8192) {
+      identitySaturated = true;
+      return;
+    }
+    map.set(key, true);
+    if (map.size === 8192) {
+      identitySaturated = true;
+    }
+  };
+  const nodeKey = (ownerRunId, nodeId) => JSON.stringify([ownerRunId, nodeId]);
+  const attemptKey = (requestId, ownerRunId, nodeId) => JSON.stringify([requestId, ownerRunId, nodeId]);
+  const rememberPendingLegacyCancel = (requestId) => {
+    boundedRemember(pendingLegacyCancels, requestId);
+  };
+  const emitTerminal = (key, payload) => {
+    if (disposed || settledAttempts.has(key))
+      return;
+    rememberIdentity(settledAttempts, key);
+    options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, payload);
+  };
   subscribe(PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT, (data) => {
-    if (!data || typeof data !== "object")
+    if (!data || typeof data !== "object" || Array.isArray(data))
       return;
-    const requestId = data.requestId;
-    if (typeof requestId !== "string")
+    const value = data;
+    const requestId = value.requestId;
+    if (!validId(requestId))
+      return;
+    if (hasStructuredDelegationMarker(data)) {
+      if (Object.keys(value).some((key) => key !== "requestId" && key !== "ownerRunId" && key !== "nodeId"))
+        return;
+      const ownerRunId = value.ownerRunId;
+      const nodeId = value.nodeId;
+      if (!validId(ownerRunId) || !validId(nodeId))
+        return;
+      const key = attemptKey(requestId, ownerRunId, nodeId);
+      const controller = attemptControllers.get(key);
+      if (controller)
+        controller.abort();
+      else
+        rememberIdentity(pendingAttemptCancels, key);
       return;
-    const controller = controllers.get(requestId);
+    }
+    const controller = legacyControllers.get(requestId);
     if (controller) {
       controller.abort();
       return;
     }
-    pendingCancels.add(requestId);
+    rememberPendingLegacyCancel(requestId);
   });
   subscribe(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, async (data) => {
-    const request = parsePromptTemplateRequest(data);
-    if (!request)
+    const structuredPayload = hasStructuredDelegationMarker(data);
+    let requestId;
+    let params;
+    let structuredRequest;
+    let key;
+    let legacyRequest;
+    if (structuredPayload) {
+      const parsed = parseSubagentDelegationRequest(data);
+      if (parsed.ok === false) {
+        if (!disposed && parsed.requestId) {
+          const payload = {
+            requestId: parsed.requestId,
+            ...parsed.ownerRunId ? { ownerRunId: parsed.ownerRunId } : {},
+            ...parsed.nodeId ? { nodeId: parsed.nodeId } : {},
+            status: "invalid_request",
+            error: parsed.error
+          };
+          if (parsed.ownerRunId && parsed.nodeId) {
+            const attemptedKey = attemptKey(parsed.requestId, parsed.ownerRunId, parsed.nodeId);
+            if (!attemptControllers.has(attemptedKey))
+              emitTerminal(attemptedKey, payload);
+          } else {
+            options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, payload);
+          }
+        }
+        return;
+      }
+      structuredRequest = parsed.request;
+      requestId = parsed.request.requestId;
+      key = attemptKey(requestId, parsed.request.ownerRunId, parsed.request.nodeId);
+      params = toSubagentDelegationExecutionParams(parsed.request);
+    } else {
+      if (data && typeof data === "object" && !Array.isArray(data)) {
+        const legacy = data;
+        if ((legacy.tasks !== undefined || legacy.worktree !== undefined) && typeof legacy.requestId === "string" && legacy.requestId) {
+          options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, {
+            requestId: legacy.requestId,
+            messages: [],
+            isError: true,
+            errorText: "Legacy prompt-template tasks/worktree orchestration was removed; use workflowScript."
+          });
+          return;
+        }
+      }
+      legacyRequest = parsePromptTemplateRequest(data);
+      if (!legacyRequest)
+        return;
+      options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, {
+        ...legacyRequest,
+        messages: [],
+        isError: true,
+        errorText: "Legacy prompt-template direct delegation was removed; use workflowScript through the subagent tool or structured delegation."
+      });
       return;
+    }
+    if (!structuredRequest && legacyControllers.has(requestId))
+      return;
+    if (structuredRequest && key) {
+      if (attemptControllers.has(key) || settledAttempts.has(key))
+        return;
+      if (pendingAttemptCancels.delete(key)) {
+        emitTerminal(key, {
+          requestId,
+          ownerRunId: structuredRequest.ownerRunId,
+          nodeId: structuredRequest.nodeId,
+          status: "cancelled"
+        });
+        return;
+      }
+      if (identitySaturated) {
+        options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, {
+          requestId,
+          ownerRunId: structuredRequest.ownerRunId,
+          nodeId: structuredRequest.nodeId,
+          status: "unavailable_context",
+          error: "Delegation identity capacity is exhausted for this extension context."
+        });
+        return;
+      }
+      const active = activeOwnedNodes.get(nodeKey(structuredRequest.ownerRunId, structuredRequest.nodeId));
+      if (active) {
+        emitTerminal(key, {
+          requestId,
+          ownerRunId: structuredRequest.ownerRunId,
+          nodeId: structuredRequest.nodeId,
+          status: "duplicate_node"
+        });
+        return;
+      }
+    }
     const ctx = options.getContext();
     if (!ctx) {
-      const response = {
-        ...request,
-        messages: [],
-        isError: true,
-        errorText: "No active extension context for delegated subagent execution."
-      };
-      options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
+      if (structuredRequest && key) {
+        emitTerminal(key, {
+          requestId,
+          ownerRunId: structuredRequest.ownerRunId,
+          nodeId: structuredRequest.nodeId,
+          status: "unavailable_context",
+          error: "No active extension context for delegated subagent execution."
+        });
+      } else if (legacyRequest) {
+        options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, {
+          ...legacyRequest,
+          messages: [],
+          isError: true,
+          errorText: "No active extension context for delegated subagent execution."
+        });
+      }
       return;
     }
     const controller = new AbortController;
-    controllers.set(request.requestId, controller);
-    if (pendingCancels.delete(request.requestId)) {
-      controller.abort();
-      const response = {
-        ...request,
-        messages: [],
-        isError: true,
-        errorText: "Delegated prompt cancelled."
-      };
-      options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
-      controllers.delete(request.requestId);
+    if (structuredRequest && key) {
+      attemptControllers.set(key, controller);
+      activeOwnedNodes.set(nodeKey(structuredRequest.ownerRunId, structuredRequest.nodeId), { attemptKey: key, controller });
+    } else {
+      legacyControllers.set(requestId, controller);
+      if (pendingLegacyCancels.delete(requestId))
+        controller.abort();
+    }
+    if (controller.signal.aborted) {
+      if (structuredRequest && key) {
+        emitTerminal(key, {
+          requestId,
+          ownerRunId: structuredRequest.ownerRunId,
+          nodeId: structuredRequest.nodeId,
+          status: "cancelled"
+        });
+        activeOwnedNodes.delete(nodeKey(structuredRequest.ownerRunId, structuredRequest.nodeId));
+      } else if (legacyRequest) {
+        options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, {
+          ...legacyRequest,
+          messages: [],
+          isError: true,
+          errorText: "Delegated prompt cancelled."
+        });
+      }
+      if (key)
+        attemptControllers.delete(key);
+      else
+        legacyControllers.delete(requestId);
       return;
     }
-    options.events.emit(PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT, { requestId: request.requestId });
+    options.events.emit(structuredRequest ? SUBAGENT_DELEGATION_STARTED_EVENT : PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT, structuredRequest ? { requestId, ownerRunId: structuredRequest.ownerRunId, nodeId: structuredRequest.nodeId } : { requestId });
     try {
-      const result = await options.execute(request.requestId, request, controller.signal, ctx, (update) => {
-        const payload = toDelegationUpdate(request.requestId, update);
-        if (!payload)
+      const executeRequest = structuredRequest && options.executeStructured ? options.executeStructured : options.execute;
+      const result = await executeRequest(requestId, params, controller.signal, ctx, (update) => {
+        if (key ? !ownsAttempt(key, controller) : !ownsLegacyRequest(requestId, controller))
+          return;
+        if (structuredRequest) {
+          const payload = toSubagentDelegationUpdate(structuredRequest, update);
+          if (payload)
+            options.events.emit(SUBAGENT_DELEGATION_UPDATE_EVENT, payload);
           return;
-        options.events.emit(PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT, payload);
-      });
-      const contentText = firstTextContent(result.content);
-      const messages = buildDelegationMessages(result.details?.results?.[0] ?? {}, contentText);
-      const parallelResults = request.tasks ? request.tasks.map((task, index) => {
-        const step = result.details?.results?.[index];
-        if (!step) {
-          return {
-            agent: task.agent,
-            messages: [],
-            isError: true,
-            errorText: "Missing result for delegated parallel task."
-          };
         }
-        const exitCode = typeof step.exitCode === "number" ? step.exitCode : undefined;
-        const errorText = step.error;
-        return {
-          agent: step.agent ?? task.agent,
-          messages: buildDelegationMessages(step),
-          isError: exitCode !== undefined && exitCode !== 0 || !!errorText,
-          errorText: errorText || undefined
-        };
-      }) : undefined;
-      const response = {
-        ...request,
-        messages,
-        ...parallelResults ? { parallelResults } : {},
-        ...contentText ? { contentText } : {},
-        isError: result.isError === true,
-        errorText: result.isError ? contentText : undefined
-      };
-      options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
+        const payload = toDelegationUpdate(requestId, update);
+        if (payload)
+          options.events.emit(PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT, payload);
+      });
+      if (key ? !ownsAttempt(key, controller) : !ownsLegacyRequest(requestId, controller))
+        return;
+      if (structuredRequest && key) {
+        emitTerminal(key, toSubagentDelegationResponse(structuredRequest, result, controller.signal.aborted));
+      } else if (legacyRequest) {
+        options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, controller.signal.aborted ? { ...legacyRequest, messages: [], isError: true, errorText: "Delegated prompt cancelled." } : toPromptTemplateResponse(legacyRequest, result));
+      }
     } catch (error) {
-      const response = {
-        ...request,
-        messages: [],
-        isError: true,
-        errorText: error instanceof Error ? error.message : String(error)
-      };
-      options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
+      if (key ? !ownsAttempt(key, controller) : !ownsLegacyRequest(requestId, controller))
+        return;
+      if (structuredRequest && key) {
+        emitTerminal(key, {
+          requestId,
+          ownerRunId: structuredRequest.ownerRunId,
+          nodeId: structuredRequest.nodeId,
+          status: controller.signal.aborted ? "cancelled" : "failed",
+          ...controller.signal.aborted ? {} : { error: error instanceof Error ? error.message : String(error) }
+        });
+      } else if (legacyRequest) {
+        options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, {
+          ...legacyRequest,
+          messages: [],
+          isError: true,
+          errorText: error instanceof Error ? error.message : String(error)
+        });
+      }
     } finally {
-      controllers.delete(request.requestId);
+      if (key) {
+        if (attemptControllers.get(key) === controller)
+          attemptControllers.delete(key);
+      } else if (legacyControllers.get(requestId) === controller)
+        legacyControllers.delete(requestId);
+      if (structuredRequest) {
+        const ownedNodeKey = nodeKey(structuredRequest.ownerRunId, structuredRequest.nodeId);
+        if (activeOwnedNodes.get(ownedNodeKey)?.controller === controller)
+          activeOwnedNodes.delete(ownedNodeKey);
+      }
     }
   });
   return {
     cancelAll: () => {
-      for (const controller of controllers.values()) {
+      for (const controller of legacyControllers.values())
         controller.abort();
-      }
-      controllers.clear();
-      pendingCancels.clear();
+      for (const controller of attemptControllers.values())
+        controller.abort();
+      legacyControllers.clear();
+      attemptControllers.clear();
+      pendingLegacyCancels.clear();
+      pendingAttemptCancels.clear();
+      activeOwnedNodes.clear();
+      settledAttempts.clear();
+      identitySaturated = false;
     },
     dispose: () => {
+      disposed = true;
+      for (const controller of legacyControllers.values())
+        controller.abort();
+      for (const controller of attemptControllers.values())
+        controller.abort();
+      legacyControllers.clear();
+      attemptControllers.clear();
       for (const unsubscribe of subscriptions)
         unsubscribe();
       subscriptions.length = 0;
-      pendingCancels.clear();
+      pendingLegacyCancels.clear();
+      pendingAttemptCancels.clear();
+      activeOwnedNodes.clear();
+      settledAttempts.clear();
     }
   };
 }