@duckmind/dm-windows-x64 0.61.5 → 0.62.1

package/extensions/dm-subagents/src/slash/delegation-adapters.js

@@ -0,0 +1,274 @@
+import { cloneJsonWithinByteLimit } from "./delegation-json.js";
+export function parsePromptTemplateRequest(data) {
+  if (!data || typeof data !== "object")
+    return;
+  const value = data;
+  if (value.tasks !== undefined || value.worktree !== undefined)
+    return;
+  if (typeof value.requestId !== "string" || !value.requestId)
+    return;
+  if (typeof value.agent !== "string" || !value.agent)
+    return;
+  if (typeof value.task !== "string" || !value.task)
+    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;
+  return {
+    requestId: value.requestId,
+    agent: value.agent,
+    task: value.task,
+    context: value.context,
+    model: value.model,
+    cwd: value.cwd
+  };
+}
+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 }];
+}
+export 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,
+    ...update.details?.runId ? { runId: update.details.runId } : {},
+    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
+  };
+}
+export function toSubagentDelegationExecutionParams(request) {
+  return {
+    agent: request.agent,
+    task: request.task,
+    context: request.context,
+    cwd: request.cwd,
+    model: request.model,
+    timeoutMs: request.timeoutMs,
+    toolBudget: request.toolBudget,
+    skill: request.skill,
+    ...request.result.kind === "structured" ? { outputSchema: request.result.schema } : {},
+    acceptance: false,
+    artifacts: request.artifacts,
+    delegatedThinkingOverride: request.thinking,
+    delegatedAllowZeroToolBudget: true,
+    async: false,
+    foregroundOnly: true,
+    clarify: false
+  };
+}
+export function toSubagentDelegationUpdate(request, result) {
+  const legacy = toDelegationUpdate(request.requestId, result);
+  if (!legacy)
+    return;
+  return {
+    requestId: request.requestId,
+    ownerRunId: request.ownerRunId,
+    nodeId: request.nodeId,
+    ...legacy.runId ? { runId: legacy.runId } : {},
+    ...legacy.currentTool ? { currentTool: legacy.currentTool } : {},
+    ...legacy.currentToolArgs ? { currentToolArgs: legacy.currentToolArgs } : {},
+    ...legacy.recentOutput ? { recentOutput: legacy.recentOutput } : {},
+    ...legacy.recentOutputLines ? { recentOutputLines: legacy.recentOutputLines } : {},
+    ...legacy.recentTools ? { recentTools: legacy.recentTools } : {},
+    ...legacy.model ? { model: legacy.model } : {},
+    ...typeof legacy.toolCount === "number" ? { toolCount: legacy.toolCount } : {},
+    ...typeof legacy.durationMs === "number" ? { durationMs: legacy.durationMs } : {},
+    ...typeof legacy.tokens === "number" ? { tokens: legacy.tokens } : {}
+  };
+}
+function resolveSubagentDelegationStatus(result, aborted) {
+  if (aborted)
+    return "cancelled";
+  const child = result.details?.results?.[0];
+  if (!child)
+    return "failed";
+  if (result.details?.timedOut || child.timedOut)
+    return "timed_out";
+  if (child?.structuredOutputFailed)
+    return "structured_output_failed";
+  if (child?.toolBudgetBlocked)
+    return "tool_budget_exhausted";
+  if (child?.acceptance?.status === "rejected" && child.acceptance.explicit)
+    return "acceptance_failed";
+  if (result.details?.stopped || child?.stopped || child?.interrupted)
+    return "interrupted";
+  if (result.isError || child?.error || typeof child?.exitCode === "number" && child.exitCode !== 0)
+    return "failed";
+  return "completed";
+}
+const MAX_RESULT_BYTES = 1024 * 1024;
+export function toSubagentDelegationResponse(request, result, aborted) {
+  const child = result.details?.results?.[0];
+  const progress = child?.progressSummary ?? result.details?.progress?.[0];
+  let status = resolveSubagentDelegationStatus(result, aborted);
+  let error = child?.error ?? (status === "failed" ? firstTextContent(result.content) : undefined);
+  let projectedResult;
+  if (status === "completed") {
+    if (request.result.kind === "text") {
+      if (typeof child?.finalOutput !== "string") {
+        status = "failed";
+        error = "Delegated subagent did not capture a text result.";
+      } else if (Buffer.byteLength(child.finalOutput, "utf8") > MAX_RESULT_BYTES) {
+        status = "failed";
+        error = "Delegated text result exceeds 1 MiB when UTF-8 encoded.";
+      } else {
+        projectedResult = { kind: "text", text: child.finalOutput };
+      }
+    } else if (child?.structuredOutput === undefined) {
+      status = "failed";
+      error = "Delegated subagent did not capture the requested structured result.";
+    } else {
+      const inspected = cloneJsonWithinByteLimit(child.structuredOutput, MAX_RESULT_BYTES);
+      if (inspected.ok === false) {
+        status = "failed";
+        error = inspected.reason === "too_large" ? "Delegated structured result exceeds 1 MiB when encoded." : "Delegated structured result is not plain JSON data.";
+      } else {
+        projectedResult = { kind: "structured", value: inspected.value };
+      }
+    }
+  }
+  const usage = child?.usage;
+  const childLaunchContractDigest = child?.launchContractDigest;
+  return {
+    requestId: request.requestId,
+    ownerRunId: request.ownerRunId,
+    nodeId: request.nodeId,
+    status,
+    ...error ? { error } : {},
+    ...result.details?.runId ? { runId: result.details.runId } : {},
+    ...child?.agent ? { agent: child.agent } : {},
+    ...child?.model ? { model: child.model } : {},
+    ...child?.thinking ? { thinking: child.thinking } : {},
+    ...typeof child?.exitCode === "number" ? { exitCode: child.exitCode } : {},
+    ...childLaunchContractDigest ? { launchContractDigest: childLaunchContractDigest } : {},
+    ...projectedResult ? { result: projectedResult } : {},
+    ...usage ? {
+      usage: {
+        input: usage.input,
+        output: usage.output,
+        cacheRead: usage.cacheRead,
+        cacheWrite: usage.cacheWrite,
+        cost: usage.cost,
+        turns: usage.turns,
+        toolCalls: progress?.toolCount ?? 0,
+        durationMs: progress?.durationMs ?? 0
+      }
+    } : {}
+  };
+}
+export function toPromptTemplateResponse(request, result) {
+  const contentText = firstTextContent(result.content);
+  const messages = buildDelegationMessages(result.details?.results?.[0] ?? {}, contentText);
+  return {
+    ...request,
+    messages,
+    ...contentText ? { contentText } : {},
+    isError: result.isError === true,
+    errorText: result.isError ? contentText : undefined
+  };
+}

package/extensions/dm-subagents/src/slash/delegation-json.js

@@ -0,0 +1,113 @@
+const MAX_JSON_DEPTH = 64;
+const MAX_JSON_ENTRIES = 1e5;
+export function cloneJsonWithinByteLimit(input, maxBytes) {
+  let minimumBytes = 0;
+  let entries = 0;
+  const active = new WeakSet;
+  const addMinimumBytes = (bytes) => {
+    minimumBytes += bytes;
+    if (minimumBytes > maxBytes)
+      throw new RangeError("too_large");
+  };
+  const visit = (value, depth) => {
+    if (depth > MAX_JSON_DEPTH)
+      throw new TypeError("invalid");
+    if (value === null) {
+      addMinimumBytes(4);
+      return null;
+    }
+    if (typeof value === "boolean") {
+      addMinimumBytes(value ? 4 : 5);
+      return value;
+    }
+    if (typeof value === "number") {
+      if (!Number.isFinite(value))
+        throw new TypeError("invalid");
+      const encoded = JSON.stringify(Object.is(value, -0) ? 0 : value);
+      addMinimumBytes(Buffer.byteLength(encoded, "utf8"));
+      return Object.is(value, -0) ? 0 : value;
+    }
+    if (typeof value === "string") {
+      addMinimumBytes(Buffer.byteLength(value, "utf8") + 2);
+      return value;
+    }
+    if (typeof value !== "object")
+      throw new TypeError("invalid");
+    const object = value;
+    if (active.has(object))
+      throw new TypeError("invalid");
+    active.add(object);
+    try {
+      const prototype = Object.getPrototypeOf(object);
+      const keys = Reflect.ownKeys(object);
+      if (Array.isArray(object)) {
+        if (prototype !== Array.prototype)
+          throw new TypeError("invalid");
+        const lengthDescriptor = Object.getOwnPropertyDescriptor(object, "length");
+        if (!lengthDescriptor || !("value" in lengthDescriptor) || !Number.isSafeInteger(lengthDescriptor.value) || lengthDescriptor.value < 0) {
+          throw new TypeError("invalid");
+        }
+        const length = lengthDescriptor.value;
+        addMinimumBytes(2 + Math.max(0, length - 1));
+        const output = [];
+        for (const key of keys) {
+          if (typeof key === "symbol")
+            throw new TypeError("invalid");
+          if (key === "length")
+            continue;
+          if (!/^(?:0|[1-9][0-9]*)$/.test(key) || Number(key) >= length)
+            throw new TypeError("invalid");
+        }
+        for (let index = 0;index < length; index++) {
+          const descriptor = Object.getOwnPropertyDescriptor(object, String(index));
+          if (!descriptor || !("value" in descriptor) || !descriptor.enumerable)
+            throw new TypeError("invalid");
+          entries++;
+          if (entries > MAX_JSON_ENTRIES)
+            throw new TypeError("invalid");
+          output.push(visit(descriptor.value, depth + 1));
+        }
+        return output;
+      }
+      if (prototype !== Object.prototype && prototype !== null)
+        throw new TypeError("invalid");
+      addMinimumBytes(2 + Math.max(0, keys.length - 1));
+      const output = {};
+      for (const key of keys) {
+        if (typeof key === "symbol")
+          throw new TypeError("invalid");
+        const descriptor = Object.getOwnPropertyDescriptor(object, key);
+        if (!descriptor || !("value" in descriptor) || !descriptor.enumerable)
+          throw new TypeError("invalid");
+        entries++;
+        if (entries > MAX_JSON_ENTRIES)
+          throw new TypeError("invalid");
+        addMinimumBytes(Buffer.byteLength(JSON.stringify(key), "utf8") + 1);
+        Object.defineProperty(output, key, {
+          value: visit(descriptor.value, depth + 1),
+          enumerable: true,
+          configurable: true,
+          writable: true
+        });
+      }
+      return output;
+    } finally {
+      active.delete(object);
+    }
+  };
+  try {
+    const value = visit(input, 0);
+    const encoded = JSON.stringify(value);
+    if (encoded === undefined)
+      return { ok: false, reason: "invalid" };
+    const encodedBytes = Buffer.byteLength(encoded, "utf8");
+    if (encodedBytes > maxBytes)
+      return { ok: false, reason: "too_large" };
+    return { ok: true, value, encodedBytes };
+  } catch (error) {
+    return {
+      ok: false,
+      reason: error instanceof RangeError && error.message === "too_large" ? "too_large" : "invalid"
+    };
+  }
+}

package/extensions/dm-subagents/src/slash/delegation-request.js

@@ -0,0 +1,152 @@
+import { validateToolBudgetConfig } from "../runs/shared/tool-budget.js";
+import { cloneJsonWithinByteLimit } from "./delegation-json.js";
+const supportedFields = new Set([
+  "requestId",
+  "ownerRunId",
+  "nodeId",
+  "agent",
+  "task",
+  "context",
+  "cwd",
+  "model",
+  "thinking",
+  "timeoutMs",
+  "toolBudget",
+  "skill",
+  "artifacts",
+  "result"
+]);
+const thinkingLevels = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+const MAX_SCHEMA_BYTES = 64 * 1024;
+const MAX_TASK_BYTES = 1024 * 1024;
+const MAX_CWD_BYTES = 32 * 1024;
+const MAX_SHORT_TEXT_BYTES = 1024;
+const MAX_SKILL_ENTRIES = 256;
+const MAX_SKILL_AGGREGATE_BYTES = 64 * 1024;
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function validateId(value) {
+  if (!nonEmptyString(value) || value.length > 256 || /[\r\n]/.test(value))
+    return;
+  return value;
+}
+export function parseSubagentDelegationRequest(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    return { ok: false, error: "Delegation request must be an object." };
+  }
+  const value = data;
+  const requestId = validateId(value.requestId);
+  if (!requestId) {
+    return { ok: false, error: "Delegation requestId must be a non-empty string of at most 256 characters without newlines." };
+  }
+  const ownerRunId = validateId(value.ownerRunId);
+  if (!ownerRunId) {
+    return { ok: false, requestId, error: "Delegation ownerRunId must be a non-empty string of at most 256 characters without newlines." };
+  }
+  const nodeId = validateId(value.nodeId);
+  if (!nodeId) {
+    return { ok: false, requestId, ownerRunId, error: "Delegation nodeId must be a non-empty string of at most 256 characters without newlines." };
+  }
+  const identity = { requestId, ownerRunId, nodeId };
+  const unsupportedField = Object.keys(value).find((key) => !supportedFields.has(key));
+  if (unsupportedField)
+    return { ok: false, ...identity, error: `Unsupported delegation field: ${unsupportedField}.` };
+  if (!nonEmptyString(value.agent))
+    return { ok: false, ...identity, error: "Delegation agent must be a non-empty string." };
+  if (!nonEmptyString(value.task))
+    return { ok: false, ...identity, error: "Delegation task must be a non-empty string." };
+  if (value.context !== "fresh" && value.context !== "fork") {
+    return { ok: false, ...identity, error: "Delegation context must be fresh or fork." };
+  }
+  if (!nonEmptyString(value.cwd))
+    return { ok: false, ...identity, error: "Delegation cwd must be a non-empty string." };
+  if (value.model !== undefined && !nonEmptyString(value.model)) {
+    return { ok: false, ...identity, error: "model must be a non-empty string when provided." };
+  }
+  if (value.timeoutMs !== undefined && (typeof value.timeoutMs !== "number" || !Number.isInteger(value.timeoutMs) || value.timeoutMs < 1)) {
+    return { ok: false, ...identity, error: "timeoutMs must be an integer >= 1." };
+  }
+  const timeoutMs = typeof value.timeoutMs === "number" ? value.timeoutMs : undefined;
+  if (timeoutMs !== undefined && timeoutMs > 2147483647) {
+    return { ok: false, ...identity, error: "timeoutMs must be <= 2147483647." };
+  }
+  if (value.toolBudget && typeof value.toolBudget === "object" && !Array.isArray(value.toolBudget)) {
+    const unsupportedToolBudgetField = Object.keys(value.toolBudget).find((key) => key !== "soft" && key !== "hard" && key !== "block");
+    if (unsupportedToolBudgetField) {
+      return { ok: false, ...identity, error: `toolBudget.${unsupportedToolBudgetField} is not supported.` };
+    }
+  }
+  const toolBudget = validateToolBudgetConfig(value.toolBudget, "toolBudget", { minimumHard: 0 });
+  if (toolBudget.error)
+    return { ok: false, ...identity, error: toolBudget.error };
+  if (value.skill !== undefined) {
+    const validSkill = typeof value.skill === "boolean" || nonEmptyString(value.skill) || Array.isArray(value.skill) && value.skill.length > 0 && value.skill.every(nonEmptyString);
+    if (!validSkill) {
+      return { ok: false, ...identity, error: "skill must be a boolean, non-empty string, or non-empty string array." };
+    }
+  }
+  if (value.artifacts !== undefined && typeof value.artifacts !== "boolean") {
+    return { ok: false, ...identity, error: "artifacts must be a boolean." };
+  }
+  if (Buffer.byteLength(value.task, "utf8") > MAX_TASK_BYTES) {
+    return { ok: false, ...identity, error: "Delegation task exceeds 1 MiB when UTF-8 encoded." };
+  }
+  if (Buffer.byteLength(value.cwd, "utf8") > MAX_CWD_BYTES) {
+    return { ok: false, ...identity, error: "Delegation cwd exceeds 32 KiB when UTF-8 encoded." };
+  }
+  if (Buffer.byteLength(value.agent, "utf8") > MAX_SHORT_TEXT_BYTES) {
+    return { ok: false, ...identity, error: "Delegation agent exceeds 1 KiB when UTF-8 encoded." };
+  }
+  if (typeof value.model === "string" && Buffer.byteLength(value.model, "utf8") > MAX_SHORT_TEXT_BYTES) {
+    return { ok: false, ...identity, error: "Delegation model exceeds 1 KiB when UTF-8 encoded." };
+  }
+  const skillEntries = typeof value.skill === "string" ? [value.skill] : Array.isArray(value.skill) ? value.skill : [];
+  if (skillEntries.length > MAX_SKILL_ENTRIES) {
+    return { ok: false, ...identity, error: "Delegation skill supports at most 256 entries." };
+  }
+  if (skillEntries.some((entry) => Buffer.byteLength(entry, "utf8") > MAX_SHORT_TEXT_BYTES)) {
+    return { ok: false, ...identity, error: "Delegation skill entry exceeds 1 KiB when UTF-8 encoded." };
+  }
+  if (skillEntries.reduce((total, entry) => total + Buffer.byteLength(entry, "utf8"), 0) > MAX_SKILL_AGGREGATE_BYTES) {
+    return { ok: false, ...identity, error: "Delegation skill entries exceed 64 KiB in aggregate when UTF-8 encoded." };
+  }
+  if (value.thinking !== undefined && (typeof value.thinking !== "string" || !thinkingLevels.has(value.thinking))) {
+    return { ok: false, ...identity, error: "thinking must be one of off, minimal, low, medium, high, xhigh, or max." };
+  }
+  if (!value.result || typeof value.result !== "object" || Array.isArray(value.result)) {
+    return { ok: false, ...identity, error: 'result must be { kind: "text" } or { kind: "structured", schema: object }.' };
+  }
+  const result = value.result;
+  let structuredSchema;
+  if (result.kind === "text") {
+    const unsupportedResultField = Object.keys(result).find((key) => key !== "kind");
+    if (unsupportedResultField)
+      return { ok: false, ...identity, error: `result.${unsupportedResultField} is not supported for text results.` };
+  } else if (result.kind === "structured") {
+    const unsupportedResultField = Object.keys(result).find((key) => key !== "kind" && key !== "schema");
+    if (unsupportedResultField)
+      return { ok: false, ...identity, error: `result.${unsupportedResultField} is not supported for structured results.` };
+    if (!result.schema || typeof result.schema !== "object" || Array.isArray(result.schema)) {
+      return { ok: false, ...identity, error: "result.schema must be a JSON Schema object." };
+    }
+    const inspectedSchema = cloneJsonWithinByteLimit(result.schema, MAX_SCHEMA_BYTES);
+    if (inspectedSchema.ok === false) {
+      return {
+        ok: false,
+        ...identity,
+        error: inspectedSchema.reason === "too_large" ? "result.schema exceeds 64 KiB when encoded." : "result.schema must be plain JSON data."
+      };
+    }
+    structuredSchema = inspectedSchema.value;
+  } else {
+    return { ok: false, ...identity, error: "result.kind must be text or structured." };
+  }
+  return {
+    ok: true,
+    request: {
+      ...value,
+      result: structuredSchema ? { kind: "structured", schema: structuredSchema } : { kind: "text" }
+    }
+  };
+}