@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/runs/shared/structured-output.js

@@ -1,15 +1,120 @@
 import * as fs from "node:fs";
+import { createRequire } from "node:module";
 import * as os from "node:os";
 import * as path from "node:path";
-import { Compile } from "typebox/compile";
+import { pathToFileURL } from "node:url";
+import { DM_CODING_AGENT_PACKAGE_ROOT_ENV } from "../../shared/utils.js";
 export const STRUCTURED_OUTPUT_SCHEMA_ENV = "DM_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA";
 export const STRUCTURED_OUTPUT_CAPTURE_ENV = "DM_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE";
+export const STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE_ENV = "DM_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE";
+export const MISSING_STRUCTURED_OUTPUT_CALL_ERROR = "Missing structured_output call; this step has outputSchema and must finish by calling structured_output.";
+const SCHEMA_MAP_KEYWORDS = ["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"];
+const SCHEMA_SINGLE_KEYWORDS = ["additionalItems", "additionalProperties", "contains", "not", "propertyNames", "if", "then", "else", "unevaluatedItems", "unevaluatedProperties", "contentSchema"];
+const SCHEMA_ARRAY_KEYWORDS = ["allOf", "anyOf", "oneOf", "prefixItems"];
+function rewriteLocalJsonPointerRefs(schema, pointerPrefix, inheritsWrapperResource = true) {
+  if (typeof schema === "boolean" || !schema || typeof schema !== "object" || Array.isArray(schema))
+    return schema;
+  const source = schema;
+  const rewritten = { ...source };
+  const sharesWrapperResource = inheritsWrapperResource && typeof source.$id !== "string";
+  if (sharesWrapperResource) {
+    for (const keyword of ["$ref", "$dynamicRef", "$recursiveRef"]) {
+      const ref = source[keyword];
+      if (ref === "#")
+        rewritten[keyword] = pointerPrefix;
+      else if (typeof ref === "string" && ref.startsWith("#/"))
+        rewritten[keyword] = `${pointerPrefix}${ref.slice(1)}`;
+    }
+  }
+  for (const keyword of SCHEMA_MAP_KEYWORDS) {
+    const entries = source[keyword];
+    if (!entries || typeof entries !== "object" || Array.isArray(entries))
+      continue;
+    rewritten[keyword] = Object.fromEntries(Object.entries(entries).map(([name, nested]) => [
+      name,
+      rewriteLocalJsonPointerRefs(nested, pointerPrefix, sharesWrapperResource)
+    ]));
+  }
+  const items = source.items;
+  if (Array.isArray(items))
+    rewritten.items = items.map((nested) => rewriteLocalJsonPointerRefs(nested, pointerPrefix, sharesWrapperResource));
+  else if (items !== undefined)
+    rewritten.items = rewriteLocalJsonPointerRefs(items, pointerPrefix, sharesWrapperResource);
+  for (const keyword of SCHEMA_SINGLE_KEYWORDS) {
+    if (source[keyword] !== undefined)
+      rewritten[keyword] = rewriteLocalJsonPointerRefs(source[keyword], pointerPrefix, sharesWrapperResource);
+  }
+  for (const keyword of SCHEMA_ARRAY_KEYWORDS) {
+    if (Array.isArray(source[keyword]))
+      rewritten[keyword] = source[keyword].map((nested) => rewriteLocalJsonPointerRefs(nested, pointerPrefix, sharesWrapperResource));
+  }
+  const dependencies = source.dependencies;
+  if (dependencies && typeof dependencies === "object" && !Array.isArray(dependencies)) {
+    rewritten.dependencies = Object.fromEntries(Object.entries(dependencies).map(([name, nested]) => [
+      name,
+      Array.isArray(nested) ? nested : rewriteLocalJsonPointerRefs(nested, pointerPrefix, sharesWrapperResource)
+    ]));
+  }
+  return rewritten;
+}
+export function createStructuredOutputToolParameters(schema, options = {}) {
+  return {
+    type: "object",
+    properties: {
+      value: rewriteLocalJsonPointerRefs(schema, "#/properties/value"),
+      ...options.acceptanceReport ? { acceptanceReport: { type: "object" } } : {}
+    },
+    required: ["value"],
+    additionalProperties: false
+  };
+}
+let cachedCompile;
+export async function resolveCompileFromPackageRoot(packageRoot) {
+  const requireFromRoot = createRequire(path.join(packageRoot, "package.json"));
+  const resolved = requireFromRoot.resolve("typebox/compile");
+  const mod = await import(pathToFileURL(resolved).href);
+  return typeof mod.Compile === "function" ? mod.Compile : undefined;
+}
+async function importCompile() {
+  const failures = [];
+  try {
+    const mod = await import("typebox/compile");
+    if (typeof mod.Compile === "function")
+      return mod.Compile;
+    failures.push("typebox/compile did not export a Compile function");
+  } catch (error) {
+    failures.push(`direct import failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const packageRoot = process.env[DM_CODING_AGENT_PACKAGE_ROOT_ENV];
+  if (packageRoot) {
+    try {
+      const compile = await resolveCompileFromPackageRoot(packageRoot);
+      if (compile)
+        return compile;
+      failures.push("DM package root typebox/compile did not export a Compile function");
+    } catch (error) {
+      failures.push(`DM package root import failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  } else {
+    failures.push(`${DM_CODING_AGENT_PACKAGE_ROOT_ENV} is not set`);
+  }
+  throw new Error(`Cannot load typebox/compile for structured output validation (${failures.join("; ")})`);
+}
+function loadCompile() {
+  if (!cachedCompile) {
+    cachedCompile = importCompile().catch((error) => {
+      cachedCompile = undefined;
+      throw error;
+    });
+  }
+  return cachedCompile;
+}
 export function assertJsonSchemaObject(schema, label = "outputSchema") {
   if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
     throw new Error(`${label} must be a JSON Schema object.`);
   }
 }
-export function createStructuredOutputRuntime(schema, baseDir) {
+export function createStructuredOutputRuntime(schema, baseDir, options = {}) {
   assertJsonSchemaObject(schema);
   const rootDir = baseDir ?? os.tmpdir();
   fs.mkdirSync(rootDir, { recursive: true });
@@ -17,12 +122,13 @@ export function createStructuredOutputRuntime(schema, baseDir) {
   const schemaPath = path.join(dir, "schema.json");
   const outputPath = path.join(dir, "output.json");
   fs.writeFileSync(schemaPath, JSON.stringify(schema), { mode: 384 });
-  return { schema, schemaPath, outputPath };
+  return { schema, schemaPath, outputPath, ...options.captureAcceptanceReport ? { acceptanceReportPath: path.join(dir, "acceptance-report.json") } : {} };
 }
-export function validateStructuredOutputValue(schema, value) {
+export async function validateStructuredOutputValue(schema, value) {
+  const compile = await loadCompile();
   let validator;
   try {
-    validator = Compile(schema);
+    validator = compile(schema);
   } catch (error) {
     return { status: "invalid", message: `invalid outputSchema: ${error instanceof Error ? error.message : String(error)}` };
   }
@@ -34,9 +140,9 @@ export function validateStructuredOutputValue(schema, value) {
   });
   return { status: "invalid", message: errors.join("; ") || "schema validation failed" };
 }
-export function readStructuredOutput(runtime) {
+export async function readStructuredOutput(runtime) {
   if (!fs.existsSync(runtime.outputPath)) {
-    return { error: "Missing structured_output call; this step has outputSchema and must finish by calling structured_output." };
+    return { error: MISSING_STRUCTURED_OUTPUT_CALL_ERROR };
   }
   let value;
   try {
@@ -44,11 +150,24 @@ export function readStructuredOutput(runtime) {
   } catch (error) {
     return { error: `Failed to read structured output: ${error instanceof Error ? error.message : String(error)}` };
   }
-  const validation = validateStructuredOutputValue(runtime.schema, value);
-  if (validation.status === "invalid")
-    return { error: `Structured output validation failed: ${validation.message}` };
+  try {
+    const validation = await validateStructuredOutputValue(runtime.schema, value);
+    if (validation.status === "invalid")
+      return { error: `Structured output validation failed: ${validation.message}` };
+  } catch (error) {
+    return { error: `Failed to validate structured output: ${error instanceof Error ? error.message : String(error)}` };
+  }
   return { value };
 }
+export function readStructuredOutputAcceptanceReport(runtime) {
+  if (!runtime.acceptanceReportPath || !fs.existsSync(runtime.acceptanceReportPath))
+    return {};
+  try {
+    return { value: JSON.parse(fs.readFileSync(runtime.acceptanceReportPath, "utf-8")) };
+  } catch (error) {
+    return { error: `Failed to read structured output acceptance report: ${error instanceof Error ? error.message : String(error)}` };
+  }
+}
 export function cleanupStructuredOutputRuntime(runtime) {
   if (!runtime)
     return;

package/extensions/dm-subagents/src/runs/shared/subagent-control.js

@@ -1,9 +1,13 @@
+import { isToolTimeoutExempt } from "./tool-timeout.js";
+import { createHash } from "node:crypto";
+import { previewDisplayText } from "../../shared/display-text.js";
 const CONTROL_EVENT_TYPES = ["active_long_running", "needs_attention"];
 const CONTROL_NOTIFICATION_CHANNELS = ["event", "async", "intercom"];
 const DEFAULT_NOTIFY_ON = ["active_long_running", "needs_attention"];
 export const DEFAULT_CONTROL_CONFIG = {
   enabled: true,
   needsAttentionAfterMs: 60000,
+  needsAttentionAfterMsIsExplicit: false,
   activeNoticeAfterMs: 240000,
   failedToolAttemptsBeforeAttention: 3,
   notifyOn: DEFAULT_NOTIFY_ON,
@@ -27,7 +31,10 @@ function parseControlList(value, allowed) {
 }
 export function resolveControlConfig(globalConfig, override) {
   const enabled = override?.enabled ?? globalConfig?.enabled ?? DEFAULT_CONTROL_CONFIG.enabled;
-  const needsAttentionAfterMs = parsePositiveInt(override?.needsAttentionAfterMs) ?? parsePositiveInt(globalConfig?.needsAttentionAfterMs) ?? DEFAULT_CONTROL_CONFIG.needsAttentionAfterMs;
+  const overrideNeedsAttentionAfterMs = parsePositiveInt(override?.needsAttentionAfterMs);
+  const globalNeedsAttentionAfterMs = parsePositiveInt(globalConfig?.needsAttentionAfterMs);
+  const needsAttentionAfterMs = overrideNeedsAttentionAfterMs ?? globalNeedsAttentionAfterMs ?? DEFAULT_CONTROL_CONFIG.needsAttentionAfterMs;
+  const needsAttentionAfterMsIsExplicit = overrideNeedsAttentionAfterMs !== undefined || globalNeedsAttentionAfterMs !== undefined;
   const activeNoticeAfterMs = parsePositiveInt(override?.activeNoticeAfterMs) ?? parsePositiveInt(globalConfig?.activeNoticeAfterMs) ?? DEFAULT_CONTROL_CONFIG.activeNoticeAfterMs;
   const activeNoticeAfterTurns = parsePositiveInt(override?.activeNoticeAfterTurns) ?? parsePositiveInt(globalConfig?.activeNoticeAfterTurns);
   const activeNoticeAfterTokens = parsePositiveInt(override?.activeNoticeAfterTokens) ?? parsePositiveInt(globalConfig?.activeNoticeAfterTokens);
@@ -37,6 +44,7 @@ export function resolveControlConfig(globalConfig, override) {
   return {
     enabled,
     needsAttentionAfterMs,
+    needsAttentionAfterMsIsExplicit,
     activeNoticeAfterMs,
     activeNoticeAfterTurns,
     activeNoticeAfterTokens,
@@ -45,13 +53,36 @@ export function resolveControlConfig(globalConfig, override) {
     notifyChannels: [...notifyChannels]
   };
 }
+function scaledNeedsAttentionAfterMs(config, thinking) {
+  if (config.needsAttentionAfterMsIsExplicit !== false)
+    return config.needsAttentionAfterMs;
+  switch (thinking) {
+    case "medium":
+      return config.needsAttentionAfterMs * 2;
+    case "high":
+      return config.needsAttentionAfterMs * 5;
+    case "xhigh":
+    case "max":
+      return config.needsAttentionAfterMs * 10;
+    default:
+      return config.needsAttentionAfterMs;
+  }
+}
 export function deriveActivityState(input) {
-  if (!input.config.enabled)
+  if (!input.config.enabled || input.currentTool)
     return;
   const now = input.now ?? Date.now();
   const lastActivity = input.lastActivityAt ?? input.startedAt;
   const ageMs = Math.max(0, now - lastActivity);
-  return ageMs > input.config.needsAttentionAfterMs ? "needs_attention" : undefined;
+  return ageMs > scaledNeedsAttentionAfterMs(input.config, input.thinking) ? "needs_attention" : undefined;
+}
+export function shouldEmitOpenToolAttention(input) {
+  if (!input.config.enabled || !input.currentTool || input.currentToolStartedAt === undefined)
+    return false;
+  if (isToolTimeoutExempt(input.currentTool))
+    return false;
+  const now = input.now ?? Date.now();
+  return Math.max(0, now - input.currentToolStartedAt) >= input.config.activeNoticeAfterMs;
 }
 export function buildControlEvent(input) {
   const ts = input.ts ?? Date.now();
@@ -76,7 +107,11 @@ export function buildControlEvent(input) {
     ...input.currentToolDurationMs !== undefined ? { currentToolDurationMs: input.currentToolDurationMs } : {},
     ...input.currentPath ? { currentPath: input.currentPath } : {},
     ...elapsedMs !== undefined ? { elapsedMs } : {},
-    ...input.recentFailureSummary ? { recentFailureSummary: input.recentFailureSummary } : {}
+    ...input.recentFailureSummary ? { recentFailureSummary: input.recentFailureSummary } : {},
+    ...input.workflowKey ? { workflowKey: input.workflowKey } : {},
+    ...input.phase ? { phase: input.phase } : {},
+    ...input.label ? { label: input.label } : {},
+    ...input.taskPreview ? { taskPreview: previewDisplayText(input.taskPreview, 160) } : {}
   };
 }
 export function shouldNotifyControlEvent(config, event) {
@@ -84,7 +119,8 @@ export function shouldNotifyControlEvent(config, event) {
 }
 export function controlNotificationKey(event, childIntercomTarget) {
   const childKey = childIntercomTarget ?? (event.index !== undefined ? `${event.runId}:${event.index}` : event.runId);
-  return `${childKey}:${event.type}:${event.reason ?? "idle"}`;
+  const contextHash = createHash("sha256").update(formatControlNudge(event)).digest("hex").slice(0, 8);
+  return `${childKey}:${event.type}:${event.reason ?? "idle"}:${contextHash}`;
 }
 export function claimControlNotification(config, event, seenKeys, childIntercomTarget) {
   if (!shouldNotifyControlEvent(config, event))
@@ -111,6 +147,18 @@ function formatLongRunningFacts(event) {
     facts.push(`path ${event.currentPath}`);
   return facts.length > 0 ? facts.join(" | ") : undefined;
 }
+export function formatControlNudge(event) {
+  const scope = event.label ?? event.phase ?? event.workflowKey ?? event.taskPreview;
+  if (event.recentFailureSummary)
+    return previewDisplayText(`Resolve the recent failure${scope ? ` for ${scope}` : ""}: ${event.recentFailureSummary}. Report the smallest next step or ask for a decision.`, 160);
+  if (event.currentTool || event.currentPath) {
+    const current = [event.currentTool ? `tool ${event.currentTool}` : undefined, event.currentPath ? `path ${event.currentPath}` : undefined].filter(Boolean).join(" at ");
+    return previewDisplayText(`Check ${current}${scope ? ` for ${scope}` : ""}. Report the smallest next step or ask for a decision.`, 160);
+  }
+  if (scope)
+    return previewDisplayText(`Continue ${scope}. Report the smallest next step or ask for a decision.`, 160);
+  return "What are you blocked on? Reply with the smallest next step or ask for a decision.";
+}
 export function formatControlNoticeMessage(event, childIntercomTarget) {
   const runTarget = event.runId;
   if (event.reason === "completion_guard") {
@@ -123,8 +171,9 @@ export function formatControlNoticeMessage(event, childIntercomTarget) {
     ].filter((line) => Boolean(line)).join(`
 `);
   }
-  const nudgeMessage = "What are you blocked on? Reply with the smallest next step or ask for a decision.";
-  const nudgeCommand = `subagent({ action: "resume", id: "${runTarget}", ${event.index !== undefined ? `index: ${event.index}, ` : ""}message: "${nudgeMessage}" })`;
+  const nudgeMessage = formatControlNudge(event);
+  const steerCommand = `subagent({ action: "steer", id: "${runTarget}", ${event.index !== undefined ? `index: ${event.index}, ` : ""}message: ${JSON.stringify(nudgeMessage)} })`;
+  const nestedResumeCommand = `subagent({ action: "resume", id: "${runTarget}", message: ${JSON.stringify(nudgeMessage)} })`;
   if (event.type === "active_long_running") {
     const facts = formatLongRunningFacts(event);
     return [
@@ -132,21 +181,27 @@ export function formatControlNoticeMessage(event, childIntercomTarget) {
       `Run: ${runTarget}${event.index !== undefined ? ` step ${event.index + 1}` : ""}`,
       `Signal: ${event.message}`,
       facts ? `Facts: ${facts}` : undefined,
-      "Hint: Inspect status, then nudge if the work seems stuck. Live async nudges interrupt the child before sending the follow-up.",
-      `Nudge: ${nudgeCommand}`,
+      "Hint: Inspect status first. Use steer for a top-level live async child, routed resume for a live nested child, or resume to revive a paused/completed/failed child.",
+      `Top-level live async nudge: ${steerCommand}`,
+      `Routed live nested nudge: ${nestedResumeCommand}`,
       childIntercomTarget ? `Direct intercom target: ${childIntercomTarget}` : undefined,
       `Status: subagent({ action: "status", id: "${runTarget}" })`,
       `Interrupt: subagent({ action: "interrupt", id: "${runTarget}" })`
     ].filter((line) => Boolean(line)).join(`
 `);
   }
+  const supervisorHint = event.reason === "supervisor_request" ? "Supervisor request: reply to the pending request. If subagent_supervisor pending is empty, check intercom pending because an external intercom tool may own the request." : undefined;
+  const facts = formatLongRunningFacts(event);
   return [
     `Subagent needs attention: ${event.agent}`,
     `Run: ${runTarget}${event.index !== undefined ? ` step ${event.index + 1}` : ""}`,
     `Signal: ${event.message}`,
+    facts ? `Facts: ${facts}` : undefined,
     event.recentFailureSummary ? `Recent failures: ${event.recentFailureSummary}` : undefined,
-    "Hint: Inspect status first unless the run is clearly blocked. Live async nudges interrupt the child before sending the follow-up.",
-    `Nudge: ${nudgeCommand}`,
+    supervisorHint,
+    "Hint: Inspect status first unless the run is clearly blocked. Use steer for a top-level live async child, routed resume for a live nested child, or resume to revive a paused/completed/failed child.",
+    `Top-level live async nudge: ${steerCommand}`,
+    `Routed live nested nudge: ${nestedResumeCommand}`,
     childIntercomTarget ? `Direct intercom target: ${childIntercomTarget}` : undefined,
     `Status: subagent({ action: "status", id: "${runTarget}" })`,
     `Interrupt: subagent({ action: "interrupt", id: "${runTarget}" })`