@soimy/dingtalk 3.6.11 → 3.7.0

package/src/card/reasoning-answer-split.ts

@@ -1,162 +1,166 @@
 export interface CardReasoningAnswerSplit {
-    reasoningText?: string;
-    answerText?: string;
+  reasoningText?: string;
+  answerText?: string;
 }
 
 const THINKING_TAG_RE = /<\s*(\/?)\s*(?:think(?:ing)?|thought|antthinking)\b[^<>]*>/gi;
 
 function isWrappedReasoningLine(line: string): boolean {
-    const trimmed = line.trim();
-    return trimmed.startsWith("_") && trimmed.endsWith("_") && trimmed.length >= 3;
+  const trimmed = line.trim();
+  return trimmed.startsWith("_") && trimmed.endsWith("_") && trimmed.length >= 3;
 }
 
 function cleanReasoningLine(line: string): string {
-    const trimmed = line.trim();
-    if (!trimmed) {
-        return "";
-    }
-    return trimmed.replace(/^_/, "").replace(/_$/, "").trim();
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return "";
+  }
+  return trimmed.replace(/^_/, "").replace(/_$/, "").trim();
 }
 
 function joinAnswerParts(parts: string[]): string | undefined {
-    const joined = parts.map((part) => part.trim()).filter(Boolean).join("\n\n").trim();
-    return joined || undefined;
+  const joined = parts
+    .map((part) => part.trim())
+    .filter(Boolean)
+    .join("\n\n")
+    .trim();
+  return joined || undefined;
 }
 
 function hasStructuredMarkdown(text: string): boolean {
-    const trimmed = text.trim();
-    if (!trimmed) {
-        return false;
-    }
-    return (
-        trimmed.includes("**")
-        || trimmed.includes("```")
-        || /(^|\n)\s*(?:[-*+]\s|#{1,6}\s|>\s|\d+\.\s)/.test(trimmed)
-    );
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return false;
+  }
+  return (
+    trimmed.includes("**") ||
+    trimmed.includes("```") ||
+    /(^|\n)\s*(?:[-*+]\s|#{1,6}\s|>\s|\d+\.\s)/.test(trimmed)
+  );
 }
 
 function splitTopLevelReasoningPrefix(text: string): CardReasoningAnswerSplit | null {
-    const markerIndex = text.indexOf("Reasoning:");
-    if (markerIndex < 0) {
-        return null;
-    }
+  const markerIndex = text.indexOf("Reasoning:");
+  if (markerIndex < 0) {
+    return null;
+  }
+
+  const before = text.slice(0, markerIndex).trim();
+  if (before && hasStructuredMarkdown(before)) {
+    return {
+      answerText: text,
+    };
+  }
+
+  const trailing = text.slice(markerIndex + "Reasoning:".length);
+  const lines = trailing.split("\n");
+  const reasoningLines: string[] = [];
+  let started = false;
+  let remainderIndex = -1;
 
-    const before = text.slice(0, markerIndex).trim();
-    if (before && hasStructuredMarkdown(before)) {
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const trimmed = line.trim();
+
+    if (!started) {
+      if (!trimmed) {
+        continue;
+      }
+      if (!isWrappedReasoningLine(trimmed)) {
         return {
-            answerText: text,
+          answerText: text,
         };
+      }
+      started = true;
+      reasoningLines.push(cleanReasoningLine(trimmed));
+      continue;
     }
 
-    const trailing = text.slice(markerIndex + "Reasoning:".length);
-    const lines = trailing.split("\n");
-    const reasoningLines: string[] = [];
-    let started = false;
-    let remainderIndex = -1;
-
-    for (let index = 0; index < lines.length; index += 1) {
-        const line = lines[index];
-        const trimmed = line.trim();
-
-        if (!started) {
-            if (!trimmed) {
-                continue;
-            }
-            if (!isWrappedReasoningLine(trimmed)) {
-                return {
-                    answerText: text,
-                };
-            }
-            started = true;
-            reasoningLines.push(cleanReasoningLine(trimmed));
-            continue;
-        }
-
-        if (!trimmed) {
-            continue;
-        }
-
-        if (isWrappedReasoningLine(trimmed)) {
-            reasoningLines.push(cleanReasoningLine(trimmed));
-            continue;
-        }
-
-        remainderIndex = index;
-        break;
+    if (!trimmed) {
+      continue;
     }
 
-    if (reasoningLines.length === 0) {
-        return {
-            answerText: text,
-        };
+    if (isWrappedReasoningLine(trimmed)) {
+      reasoningLines.push(cleanReasoningLine(trimmed));
+      continue;
     }
 
-    const after = remainderIndex >= 0 ? lines.slice(remainderIndex).join("\n").trim() : "";
+    remainderIndex = index;
+    break;
+  }
+
+  if (reasoningLines.length === 0) {
     return {
-        reasoningText: reasoningLines.join("\n").trim() || undefined,
-        answerText: joinAnswerParts([before, after]),
+      answerText: text,
     };
+  }
+
+  const after = remainderIndex >= 0 ? lines.slice(remainderIndex).join("\n").trim() : "";
+  return {
+    reasoningText: reasoningLines.join("\n").trim() || undefined,
+    answerText: joinAnswerParts([before, after]),
+  };
 }
 
 function splitTopLevelThinkingTags(text: string): CardReasoningAnswerSplit | null {
-    if (!THINKING_TAG_RE.test(text)) {
-        return null;
-    }
-    THINKING_TAG_RE.lastIndex = 0;
-
-    let reasoning = "";
-    let answer = "";
-    let lastIndex = 0;
-    let inThinking = false;
-
-    for (const match of text.matchAll(THINKING_TAG_RE)) {
-        const matchIndex = match.index ?? 0;
-        const segment = text.slice(lastIndex, matchIndex);
-        if (inThinking) {
-            reasoning += segment;
-        } else {
-            answer += segment;
-        }
-        inThinking = match[1] !== "/";
-        lastIndex = matchIndex + match[0].length;
-    }
-
-    const tail = text.slice(lastIndex);
+  if (!THINKING_TAG_RE.test(text)) {
+    return null;
+  }
+  THINKING_TAG_RE.lastIndex = 0;
+
+  let reasoning = "";
+  let answer = "";
+  let lastIndex = 0;
+  let inThinking = false;
+
+  for (const match of text.matchAll(THINKING_TAG_RE)) {
+    const matchIndex = match.index ?? 0;
+    const segment = text.slice(lastIndex, matchIndex);
     if (inThinking) {
-        reasoning += tail;
+      reasoning += segment;
     } else {
-        answer += tail;
+      answer += segment;
     }
-
-    const cleanedReasoning = reasoning.trim();
-    if (!cleanedReasoning) {
-        return {
-            answerText: text,
-        };
-    }
-
+    inThinking = match[1] !== "/";
+    lastIndex = matchIndex + match[0].length;
+  }
+
+  const tail = text.slice(lastIndex);
+  if (inThinking) {
+    reasoning += tail;
+  } else {
+    answer += tail;
+  }
+
+  const cleanedReasoning = reasoning.trim();
+  if (!cleanedReasoning) {
     return {
-        reasoningText: cleanedReasoning,
-        answerText: answer.trim() || undefined,
+      answerText: text,
     };
+  }
+
+  return {
+    reasoningText: cleanedReasoning,
+    answerText: answer.trim() || undefined,
+  };
 }
 
 export function splitCardReasoningAnswerText(text?: string): CardReasoningAnswerSplit {
-    if (typeof text !== "string") {
-        return {};
-    }
-
-    const prefixed = splitTopLevelReasoningPrefix(text);
-    if (prefixed) {
-        return prefixed;
-    }
-
-    const tagged = splitTopLevelThinkingTags(text);
-    if (tagged) {
-        return tagged;
-    }
-
-    return {
-        answerText: text,
-    };
+  if (typeof text !== "string") {
+    return {};
+  }
+
+  const prefixed = splitTopLevelReasoningPrefix(text);
+  if (prefixed) {
+    return prefixed;
+  }
+
+  const tagged = splitTopLevelThinkingTags(text);
+  if (tagged) {
+    return tagged;
+  }
+
+  return {
+    answerText: text,
+  };
 }

package/src/card/reasoning-block-assembler.ts

@@ -1,157 +1,156 @@
 export interface ReasoningBlockAssembler {
-    ingestSnapshot: (text: string | undefined) => string[];
-    flushPendingAtBoundary: () => string[];
-    reset: () => void;
+  ingestSnapshot: (text: string | undefined) => string[];
+  flushPendingAtBoundary: () => string[];
+  reset: () => void;
 }
 
 function stripReasoningPrefix(text: string): string {
-    const trimmed = text.trim();
-    if (trimmed.startsWith("Reasoning:")) {
-        return trimmed.slice("Reasoning:".length).trimStart();
-    }
-    return trimmed;
+  const trimmed = text.trim();
+  if (trimmed.startsWith("Reasoning:")) {
+    return trimmed.slice("Reasoning:".length).trimStart();
+  }
+  return trimmed;
 }
 
 function cleanReasoningLine(line: string): string {
-    return line.trim().replace(/^_/, "").replace(/_$/, "").trim();
+  return line.trim().replace(/^_/, "").replace(/_$/, "").trim();
 }
 
 function isClosedReasoningLine(line: string): boolean {
-    const trimmed = line.trim();
-    return trimmed.startsWith("_") && trimmed.endsWith("_") && trimmed.length >= 2;
+  const trimmed = line.trim();
+  return trimmed.startsWith("_") && trimmed.endsWith("_") && trimmed.length >= 2;
 }
 
 function startsReasonBlock(line: string): boolean {
-    return cleanReasoningLine(line).startsWith("Reason:");
+  return cleanReasoningLine(line).startsWith("Reason:");
 }
 
 function blocksStartWithPrefix(blocks: string[], prefix: string[]): boolean {
-    if (prefix.length > blocks.length) {
-        return false;
-    }
-    return prefix.every((entry, index) => blocks[index] === entry);
+  if (prefix.length > blocks.length) {
+    return false;
+  }
+  return prefix.every((entry, index) => blocks[index] === entry);
 }
 
 function parseReasoningSnapshot(text: string | undefined): {
-    completeBlocks: string[];
-    pendingBlock: string;
+  completeBlocks: string[];
+  pendingBlock: string;
 } {
-    const normalized = typeof text === "string" ? stripReasoningPrefix(text) : "";
-    if (!normalized.trim()) {
-        return {
-            completeBlocks: [],
-            pendingBlock: "",
-        };
-    }
-
-    const lines = normalized
-        .split("\n")
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
-
-    const completeBlocks: string[] = [];
-    let currentLines: string[] = [];
-    let currentMode: "explicit" | "implicit" | null = null;
-    let currentComplete = true;
-
-    const finalizeCurrent = () => {
-        if (currentLines.length === 0) {
-            return;
-        }
-        if (currentMode === "explicit" && currentComplete) {
-            completeBlocks.push(currentLines.join("\n"));
-        }
+  const normalized = typeof text === "string" ? stripReasoningPrefix(text) : "";
+  if (!normalized.trim()) {
+    return {
+      completeBlocks: [],
+      pendingBlock: "",
     };
+  }
 
-    for (const line of lines) {
-        if (startsReasonBlock(line)) {
-            finalizeCurrent();
-            currentLines = [cleanReasoningLine(line)];
-            currentMode = "explicit";
-            currentComplete = isClosedReasoningLine(line);
-            continue;
-        }
-
-        if (currentLines.length === 0) {
-            const trimmedLine = line.trim();
-            const cleanedLine = cleanReasoningLine(line);
-            if (!cleanedLine) {
-                continue;
-            }
-            if (!trimmedLine.startsWith("_")) {
-                continue;
-            }
-            currentLines = [cleanedLine];
-            currentMode = "implicit";
-            currentComplete = false;
-            continue;
-        }
-
-        currentLines.push(cleanReasoningLine(line));
-        currentComplete = currentMode === "explicit"
-            ? currentComplete && isClosedReasoningLine(line)
-            : false;
-    }
+  const lines = normalized
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+
+  const completeBlocks: string[] = [];
+  let currentLines: string[] = [];
+  let currentMode: "explicit" | "implicit" | null = null;
+  let currentComplete = true;
 
+  const finalizeCurrent = () => {
     if (currentLines.length === 0) {
-        return {
-            completeBlocks,
-            pendingBlock: "",
-        };
+      return;
     }
-
     if (currentMode === "explicit" && currentComplete) {
-        completeBlocks.push(currentLines.join("\n"));
-        return {
-            completeBlocks,
-            pendingBlock: "",
-        };
+      completeBlocks.push(currentLines.join("\n"));
+    }
+  };
+
+  for (const line of lines) {
+    if (startsReasonBlock(line)) {
+      finalizeCurrent();
+      currentLines = [cleanReasoningLine(line)];
+      currentMode = "explicit";
+      currentComplete = isClosedReasoningLine(line);
+      continue;
+    }
+
+    if (currentLines.length === 0) {
+      const trimmedLine = line.trim();
+      const cleanedLine = cleanReasoningLine(line);
+      if (!cleanedLine) {
+        continue;
+      }
+      if (!trimmedLine.startsWith("_")) {
+        continue;
+      }
+      currentLines = [cleanedLine];
+      currentMode = "implicit";
+      currentComplete = false;
+      continue;
     }
 
+    currentLines.push(cleanReasoningLine(line));
+    currentComplete =
+      currentMode === "explicit" ? currentComplete && isClosedReasoningLine(line) : false;
+  }
+
+  if (currentLines.length === 0) {
     return {
-        completeBlocks,
-        pendingBlock: currentLines.join("\n").trim(),
+      completeBlocks,
+      pendingBlock: "",
     };
-}
-
-export function createReasoningBlockAssembler(): ReasoningBlockAssembler {
-    let emittedBlocks: string[] = [];
-    let pendingBlock = "";
+  }
 
+  if (currentMode === "explicit" && currentComplete) {
+    completeBlocks.push(currentLines.join("\n"));
     return {
-        ingestSnapshot(text: string | undefined): string[] {
-            const parsed = parseReasoningSnapshot(text);
-            pendingBlock = parsed.pendingBlock;
-
-            if (parsed.completeBlocks.length === 0) {
-                return [];
-            }
-
-            if (blocksStartWithPrefix(parsed.completeBlocks, emittedBlocks)) {
-                const nextBlocks = parsed.completeBlocks.slice(emittedBlocks.length);
-                emittedBlocks = [...parsed.completeBlocks];
-                return nextBlocks;
-            }
-
-            if (blocksStartWithPrefix(emittedBlocks, parsed.completeBlocks)) {
-                return [];
-            }
-
-            return [];
-        },
-
-        flushPendingAtBoundary(): string[] {
-            if (!pendingBlock.trim()) {
-                return [];
-            }
-            const flushed = pendingBlock;
-            pendingBlock = "";
-            return [flushed];
-        },
-
-        reset(): void {
-            emittedBlocks = [];
-            pendingBlock = "";
-        },
+      completeBlocks,
+      pendingBlock: "",
     };
+  }
+
+  return {
+    completeBlocks,
+    pendingBlock: currentLines.join("\n").trim(),
+  };
+}
+
+export function createReasoningBlockAssembler(): ReasoningBlockAssembler {
+  let emittedBlocks: string[] = [];
+  let pendingBlock = "";
+
+  return {
+    ingestSnapshot(text: string | undefined): string[] {
+      const parsed = parseReasoningSnapshot(text);
+      pendingBlock = parsed.pendingBlock;
+
+      if (parsed.completeBlocks.length === 0) {
+        return [];
+      }
+
+      if (blocksStartWithPrefix(parsed.completeBlocks, emittedBlocks)) {
+        const nextBlocks = parsed.completeBlocks.slice(emittedBlocks.length);
+        emittedBlocks = [...parsed.completeBlocks];
+        return nextBlocks;
+      }
+
+      if (blocksStartWithPrefix(emittedBlocks, parsed.completeBlocks)) {
+        return [];
+      }
+
+      return [];
+    },
+
+    flushPendingAtBoundary(): string[] {
+      if (!pendingBlock.trim()) {
+        return [];
+      }
+      const flushed = pendingBlock;
+      pendingBlock = "";
+      return [flushed];
+    },
+
+    reset(): void {
+      emittedBlocks = [];
+      pendingBlock = "";
+    },
+  };
 }

package/src/{run-usage-store.ts → card/run-usage-store.ts}

@@ -16,7 +16,9 @@ export function recordRunStart(runId: string): void {
 
 export function accumulateUsage(runId: string, usage: UsageAccumulation): void {
   const existing = usageStore.get(runId);
-  if (!existing) { return; }
+  if (!existing) {
+    return;
+  }
 
   for (const field of ["input", "output", "cacheRead", "cacheWrite", "total"] as const) {
     const value = usage[field];
@@ -32,10 +34,14 @@ export function getUsageByRunId(runId: string): UsageAccumulation | undefined {
 
 export function getAggregatedUsage(runIds: Set<string> | undefined): UsageAccumulation {
   const result: UsageAccumulation = {};
-  if (!runIds) { return result; }
+  if (!runIds) {
+    return result;
+  }
   for (const runId of runIds) {
     const usage = usageStore.get(runId);
-    if (!usage) { continue; }
+    if (!usage) {
+      continue;
+    }
     for (const field of ["input", "output", "cacheRead", "cacheWrite", "total"] as const) {
       if (typeof usage[field] === "number") {
         result[field] = (result[field] ?? 0) + usage[field];
@@ -46,12 +52,18 @@ export function getAggregatedUsage(runIds: Set<string> | undefined): UsageAccumu
 }
 
 export function clearRun(runId: string | undefined): void {
-  if (runId) { usageStore.delete(runId); }
+  if (runId) {
+    usageStore.delete(runId);
+  }
 }
 
 export function clearRuns(runIds: Set<string> | undefined): void {
-  if (!runIds) { return; }
-  for (const runId of runIds) { usageStore.delete(runId); }
+  if (!runIds) {
+    return;
+  }
+  for (const runId of runIds) {
+    usageStore.delete(runId);
+  }
 }
 
 export function clearAllForTest(): void {

package/src/card/statusline-renderer.ts

@@ -67,8 +67,16 @@ const SEGMENTS: Segment[] = [
   { key: "effort", defaultOn: true, render: (d) => d.effort || undefined },
   { key: "agent", defaultOn: true, render: (d) => d.agent || undefined },
   { key: "tokens", defaultOn: false, render: renderTokenSegment },
-  { key: "taskTime", defaultOn: false, render: (d) => typeof d.taskTime === "number" ? formatDuration(d.taskTime) : undefined },
-  { key: "dapiUsage", defaultOn: false, render: (d) => typeof d.dapi_usage === "number" ? `DAPI+${d.dapi_usage}` : undefined },
+  {
+    key: "taskTime",
+    defaultOn: false,
+    render: (d) => (typeof d.taskTime === "number" ? formatDuration(d.taskTime) : undefined),
+  },
+  {
+    key: "dapiUsage",
+    defaultOn: false,
+    render: (d) => (typeof d.dapi_usage === "number" ? `DAPI+${d.dapi_usage}` : undefined),
+  },
 ];
 
 const SEGMENTS_PER_LINE = 3;
@@ -79,12 +87,13 @@ function resolveSegmentEnabled(seg: Segment, config: StatusLineConfig): boolean
 }
 
 export function renderStatusLine(data: StatusLineData, config: StatusLineConfig): string {
-  const rendered = SEGMENTS
-    .filter((seg) => resolveSegmentEnabled(seg, config))
+  const rendered = SEGMENTS.filter((seg) => resolveSegmentEnabled(seg, config))
     .map((seg) => seg.render(data))
     .filter(Boolean) as string[];
 
-  if (rendered.length === 0) { return ""; }
+  if (rendered.length === 0) {
+    return "";
+  }
 
   const lines: string[] = [];
   for (let i = 0; i < rendered.length; i += SEGMENTS_PER_LINE) {

package/src/card/task-model-metadata.ts

@@ -22,7 +22,10 @@ export function normalizeModelDisplayName(modelRef: string | undefined): string
   if (!trimmed) {
     return undefined;
   }
-  const parts = trimmed.split("/").map((part) => part.trim()).filter(Boolean);
+  const parts = trimmed
+    .split("/")
+    .map((part) => part.trim())
+    .filter(Boolean);
   return parts.at(-1) || undefined;
 }
 
@@ -36,11 +39,13 @@ export function resolveConfiguredTaskModelMetadata(params: {
     ? agents.list.find((entry) => String(entry.id || "").trim() === agentId)
     : undefined;
 
-  const modelRef = readPrimaryModelRef(agent?.model) ?? readPrimaryModelRef(agents?.defaults?.model);
+  const modelRef =
+    readPrimaryModelRef(agent?.model) ?? readPrimaryModelRef(agents?.defaults?.model);
   const effort =
     typeof agent?.thinkingDefault === "string" && agent.thinkingDefault.trim()
       ? agent.thinkingDefault.trim()
-      : typeof agents?.defaults?.thinkingDefault === "string" && agents.defaults.thinkingDefault.trim()
+      : typeof agents?.defaults?.thinkingDefault === "string" &&
+          agents.defaults.thinkingDefault.trim()
         ? agents.defaults.thinkingDefault.trim()
         : undefined;