@cursor/july 0.1.97 → 0.1.100

package/dist/channels/slack/reply-options.js

@@ -0,0 +1,150 @@
+/**
+ * Resolve `slackChannel({ reply, toolLabels })` — and the deprecated
+ * `streaming` / `thinkingSteps` / `loadingMessages` flags — into one config
+ * the default event handlers read.
+ */
+import { SLACK_DEFAULT_LOADING_MESSAGES } from "./constants.js";
+import { defaultToolCardDetails } from "./tool-cards.js";
+export const DEFAULT_REASONING_CARD_TITLE = "Thinking";
+/** A modest share of `SLACK_MARKDOWN_TEXT_MAX_LEN`, which the whole streamed message shares. */
+export const DEFAULT_REASONING_CARD_MAX_CHARS = 1500;
+function resolveToolLabel(labels) {
+    if (labels === undefined) {
+        return (toolName) => toolName;
+    }
+    const lookup = typeof labels === "function" ? labels : (name) => labels[name];
+    return (toolName) => {
+        const label = lookup(toolName);
+        return label === undefined || label === "" ? toolName : label;
+    };
+}
+function defaultToolStatusLine(toolLabel) {
+    return (calls) => {
+        const names = [...new Set(calls.map((call) => toolLabel(call.toolName)))];
+        return `Running ${names.join(", ")}…`;
+    };
+}
+function resolveIdle(idle) {
+    const cleaned = (idle !== null && idle !== void 0 ? idle : []).filter((line) => line.trim() !== "");
+    return cleaned.length > 0 ? cleaned : [...SLACK_DEFAULT_LOADING_MESSAGES];
+}
+function resolveReasoningCard(option) {
+    var _a;
+    if (option === undefined || option === false) {
+        return false;
+    }
+    const options = option === true ? {} : option;
+    const title = (_a = options.title) === null || _a === void 0 ? void 0 : _a.trim();
+    return {
+        title: title === undefined || title === ""
+            ? DEFAULT_REASONING_CARD_TITLE
+            : title,
+        maxChars: options.maxChars !== undefined && options.maxChars > 0
+            ? options.maxChars
+            : DEFAULT_REASONING_CARD_MAX_CHARS,
+    };
+}
+function resolveToolCards(option) {
+    var _a, _b;
+    const cards = option.toolCards;
+    if (cards === undefined || cards === false) {
+        return false;
+    }
+    if (cards === true) {
+        return { group: "per-tool", details: defaultToolCardDetails };
+    }
+    const group = (_a = cards.group) !== null && _a !== void 0 ? _a : "per-tool";
+    if (cards.collapsible === false) {
+        return { group };
+    }
+    return {
+        group,
+        details: (_b = cards.details) !== null && _b !== void 0 ? _b : defaultToolCardDetails,
+        output: cards.output,
+    };
+}
+/**
+ * Map the deprecated flags onto a `reply` shape with their old defaults
+ * (streaming on, per-call cards on), so a config that only sets these keeps
+ * behaving as it did. `null` when none of them is set.
+ */
+function legacyReplyOptions(options) {
+    const idle = options.loadingMessages;
+    if (options.streaming === undefined &&
+        options.thinkingSteps === undefined &&
+        idle === undefined) {
+        return null;
+    }
+    const deprecations = [];
+    const mode = options.streaming === false ? "post" : "stream";
+    // What legacy streaming showed: one title-only card per call.
+    const cards = options.thinkingSteps === false ? false : LEGACY_CARDS;
+    const replacement = mode === "post"
+        ? 'reply: { mode: "post" }'
+        : cards === false
+            ? 'reply: { mode: "stream" }'
+            : 'reply: { mode: "stream", toolCards: { group: "per-call", collapsible: false } }';
+    if (idle !== undefined) {
+        deprecations.push(`slackChannel({ loadingMessages }) is deprecated; use reply: { mode: "${mode}", status: { idle: [...] } }.`);
+    }
+    if (options.streaming !== undefined) {
+        deprecations.push(`slackChannel({ streaming: ${String(options.streaming)} }) is deprecated; use ${replacement}.`);
+    }
+    if (options.thinkingSteps !== undefined) {
+        deprecations.push(mode === "post"
+            ? "slackChannel({ thinkingSteps }) has no effect in post mode; remove it."
+            : `slackChannel({ thinkingSteps: ${String(options.thinkingSteps)} }) is deprecated; use ${replacement}.`);
+    }
+    const status = { idle };
+    if (mode === "post") {
+        return { reply: { mode, status }, deprecations };
+    }
+    return { reply: { mode, status, toolCards: cards }, deprecations };
+}
+const LEGACY_CARDS = { group: "per-call", collapsible: false };
+export function resolveSlackReply(options) {
+    var _a;
+    const deprecations = [];
+    let reply = { mode: "post" };
+    const legacy = legacyReplyOptions(options);
+    if (options.reply !== undefined) {
+        reply = options.reply;
+        if (legacy !== null) {
+            const ignored = ["streaming", "thinkingSteps", "loadingMessages"].filter((key) => options[key] !== undefined);
+            deprecations.push(`slackChannel({ ${ignored.join(", ")} }) is ignored because reply is set; remove the deprecated option${ignored.length === 1 ? "" : "s"}.`);
+        }
+    }
+    else if (legacy !== null) {
+        reply = legacy.reply;
+        deprecations.push(...legacy.deprecations);
+    }
+    const toolLabel = resolveToolLabel(options.toolLabels);
+    const statusInput = (_a = reply.status) !== null && _a !== void 0 ? _a : {};
+    const status = {
+        reasoning: statusInput.reasoning !== false,
+        tools: statusInput.tools === false
+            ? false
+            : typeof statusInput.tools === "function"
+                ? statusInput.tools
+                : defaultToolStatusLine(toolLabel),
+        idle: resolveIdle(statusInput.idle),
+    };
+    if (reply.mode === "post") {
+        return {
+            mode: "post",
+            status,
+            toolCards: false,
+            reasoningCard: false,
+            toolLabel,
+            deprecations,
+        };
+    }
+    return {
+        mode: "stream",
+        status,
+        toolCards: resolveToolCards(reply),
+        reasoningCard: resolveReasoningCard(reply.reasoningCard),
+        toolLabel,
+        deprecations,
+    };
+}

package/dist/channels/slack/slack-channel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slack-channel.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/slack-channel.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,OAAO,KAAK,EAEV,iBAAiB,EAMlB,MAAM,gBAAgB,CAAC;AA2CxB,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAQpB;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,GACjB,mBAAmB,GAAG,SAAS,CAEjC;AAED,0EAA0E;AAC1E,MAAM,WAAW,uBAAuB;IACtC,WAAW,EAAE,gBAAgB,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,aAAa,CAAC;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,GAC9C,uBAAuB,GAAG,SAAS,CAYrC;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,GAAE,mBAAwB,GACjC,iBAAiB,CAAC,iBAAiB,CAAC,CA4atC"}
+{"version":3,"file":"slack-channel.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/slack-channel.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,OAAO,KAAK,EAEV,iBAAiB,EAMlB,MAAM,gBAAgB,CAAC;AA4CxB,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAQpB;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,GACjB,mBAAmB,GAAG,SAAS,CAEjC;AAED,0EAA0E;AAC1E,MAAM,WAAW,uBAAuB;IACtC,WAAW,EAAE,gBAAgB,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,aAAa,CAAC;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,GAC9C,uBAAuB,GAAG,SAAS,CAYrC;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,GAAE,mBAAwB,GACjC,iBAAiB,CAAC,iBAAiB,CAAC,CAgbtC"}

package/dist/channels/slack/slack-channel.js

@@ -26,6 +26,7 @@ import { dispatchInboundFromEventBody, dispatchInboundMessage, emptySlackChannel
 import { createEventIdDedupe } from "./event-id-dedupe.js";
 import { dispatchBlockAction, dispatchInteractiveFromPayload, } from "./interactive.js";
 import { createSlackLogger } from "./log.js";
+import { resolveSlackReply } from "./reply-options.js";
 import { startSlackSocketMode, } from "./socket-mode.js";
 import { buildToolApprovalEvents } from "./tool-approval-events.js";
 /** Options used to construct a slack channel — for host-level credential binding. */
@@ -70,7 +71,8 @@ export function slackChannel(authored = {}) {
     }
     const credentials = (_a = options.credentials) !== null && _a !== void 0 ? _a : credentialsFromEnv(options.envPrefix);
     const envKeys = slackEnvKeys(options.envPrefix);
-    const loadingMessages = options.loadingMessages;
+    const reply = resolveSlackReply(options);
+    const loadingMessages = reply.status.idle;
     const policy = options.policy;
     const blockExternals = resolveSlackBlockExternals(policy);
     const defaultInbound = createDefaultOnInbound(loadingMessages, policy);
@@ -107,11 +109,13 @@ export function slackChannel(authored = {}) {
     if (options.deliverDefaults !== false) {
         Object.assign(events, buildDefaultEvents({
             credentials,
+            reply: options.reply,
+            toolLabels: options.toolLabels,
             streaming: options.streaming,
             thinkingSteps: options.thinkingSteps,
+            loadingMessages: options.loadingMessages,
             suggestedPrompts: options.suggestedPrompts,
             suggestedPromptsTitle: options.suggestedPromptsTitle,
-            loadingMessages,
             getLog,
         }));
     }
@@ -145,9 +149,9 @@ export function slackChannel(authored = {}) {
         auth: [allowAll()],
         state: emptySlackChannelState(),
         routes: [],
-        meta: Object.assign({ kind: "slack" }, (channelPosts === undefined
+        meta: Object.assign(Object.assign({ kind: "slack" }, (channelPosts === undefined
             ? {}
-            : { slackChannelPosts: [...channelPosts.allow] })),
+            : { slackChannelPosts: [...channelPosts.allow] })), { deprecations: reply.deprecations }),
         receive(input_1, _a) {
             return __awaiter(this, arguments, void 0, function* (input, { send }) {
                 var _b;

package/dist/channels/slack/stream.d.ts

@@ -2,25 +2,37 @@
  * Chat streaming helpers for Slack AI / agent features.
  */
 export type StreamTaskStatus = "pending" | "in_progress" | "complete" | "error";
+/**
+ * One update to a task card. Slack keeps one card per `id`: `title` and
+ * `status` replace the previous values, `details` and `output` are appended
+ * to what the card already shows.
+ */
 export interface StreamTaskChunk {
     type: "task_update";
     id: string;
     title: string;
     status: StreamTaskStatus;
+    details?: string;
+    output?: string;
+}
+export interface StreamMarkdownChunk {
+    type: "markdown_text";
+    text: string;
 }
+/**
+ * A `chat.*Stream` chunk. Slack fixes a stream's mode at `chat.startStream`:
+ * one opened with bare `markdown_text` rejects every later `chunks` append
+ * (`streaming_mode_mismatch`), and vice versa. The live-delivery strategy
+ * therefore always speaks chunks, wrapping text as `markdown_text` chunks so
+ * tool-step `task_update`s can share the same message.
+ */
+export type StreamChunk = StreamMarkdownChunk | StreamTaskChunk;
+export declare function markdownChunk(text: string): StreamMarkdownChunk;
 /**
  * Given previously sent cumulative text and the new cumulative text, return
  * the suffix to append. Empty string when there is nothing new to send.
  */
 export declare function computeStreamAppend(lastPostedText: string | null | undefined, cumulative: string): string;
-/** Build task_update chunks for tool calls. */
-export declare function buildTaskChunksForCalls(calls: Array<{
-    callId: string;
-    toolName: string;
-}>, status: StreamTaskStatus): StreamTaskChunk[];
-export declare function buildTaskChunkForResult(args: {
-    callId: string;
-    toolName: string;
-    isError: boolean;
-}): StreamTaskChunk;
+/** Clamp to `max` characters, ending in an ellipsis when cut. */
+export declare function truncateCardText(text: string, max: number): string;
 //# sourceMappingURL=stream.d.ts.map

package/dist/channels/slack/stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/stream.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,aAAa,GAAG,UAAU,GAAG,OAAO,CAAC;AAEhF,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,aAAa,CAAC;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;CAC1B;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACzC,UAAU,EAAE,MAAM,GACjB,MAAM,CAgBR;AAED,+CAA+C;AAC/C,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,KAAK,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,EAClD,MAAM,EAAE,gBAAgB,GACvB,eAAe,EAAE,CAOnB;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;CAClB,GAAG,eAAe,CAOlB"}
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/stream.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,aAAa,GAAG,UAAU,GAAG,OAAO,CAAC;AAEhF;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,aAAa,CAAC;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,mBAAmB,GAAG,eAAe,CAAC;AAEhE,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,CAE/D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACzC,UAAU,EAAE,MAAM,GACjB,MAAM,CAgBR;AAED,iEAAiE;AACjE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAKlE"}

package/dist/channels/slack/stream.js

@@ -1,6 +1,9 @@
 /**
  * Chat streaming helpers for Slack AI / agent features.
  */
+export function markdownChunk(text) {
+    return { type: "markdown_text", text };
+}
 /**
  * Given previously sent cumulative text and the new cumulative text, return
  * the suffix to append. Empty string when there is nothing new to send.
@@ -20,20 +23,10 @@ export function computeStreamAppend(lastPostedText, cumulative) {
     // Text rewound / rewritten — cannot unsend; skip append.
     return "";
 }
-/** Build task_update chunks for tool calls. */
-export function buildTaskChunksForCalls(calls, status) {
-    return calls.map((call) => ({
-        type: "task_update",
-        id: call.callId,
-        title: call.toolName,
-        status,
-    }));
-}
-export function buildTaskChunkForResult(args) {
-    return {
-        type: "task_update",
-        id: args.callId,
-        title: args.toolName,
-        status: args.isError ? "error" : "complete",
-    };
+/** Clamp to `max` characters, ending in an ellipsis when cut. */
+export function truncateCardText(text, max) {
+    if (text.length <= max) {
+        return text;
+    }
+    return `${text.slice(0, max - 1)}…`;
 }

package/dist/channels/slack/tool-cards.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Task cards for tool calls inside the streamed reply. One card per key:
+ * the call id for `per-call`, the tool name for `per-tool`. A card's title
+ * counts its calls and its status follows the whole group; with one call
+ * per key that reduces to the plain per-call card.
+ */
+import type { ResolvedSlackToolCards } from "./reply-options.js";
+import { type StreamTaskChunk } from "./stream.js";
+import type { SlackChannelState, SlackToolCall, SlackToolResult } from "./types.js";
+/**
+ * Default tool-card line for a call, matching the playground's tool header:
+ * the grep pattern, the glob pattern, the file path, the shell command. Other
+ * tools show a lone string argument bare, else compact JSON. No key labels,
+ * no knobs like `headLimit`.
+ */
+export declare function defaultToolCardDetails(call: SlackToolCall): string | undefined;
+export interface ToolCards {
+    forCalls(state: SlackChannelState, calls: readonly SlackToolCall[]): StreamTaskChunk[];
+    forResult(state: SlackChannelState, result: SlackToolResult): StreamTaskChunk;
+}
+export declare function createToolCards(cards: ResolvedSlackToolCards, toolLabel: (toolName: string) => string): ToolCards;
+//# sourceMappingURL=tool-cards.d.ts.map

package/dist/channels/slack/tool-cards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-cards.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/tool-cards.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,EAAE,KAAK,eAAe,EAAoB,MAAM,aAAa,CAAC;AACrE,OAAO,KAAK,EACV,iBAAiB,EACjB,aAAa,EACb,eAAe,EAEhB,MAAM,YAAY,CAAC;AAwDpB;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,aAAa,GAClB,MAAM,GAAG,SAAS,CA8BpB;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CACN,KAAK,EAAE,iBAAiB,EACxB,KAAK,EAAE,SAAS,aAAa,EAAE,GAC9B,eAAe,EAAE,CAAC;IACrB,SAAS,CAAC,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,eAAe,GAAG,eAAe,CAAC;CAC/E;AAoCD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,sBAAsB,EAC7B,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GACtC,SAAS,CAgEX"}

package/dist/channels/slack/tool-cards.js

@@ -0,0 +1,178 @@
+/**
+ * Task cards for tool calls inside the streamed reply. One card per key:
+ * the call id for `per-call`, the tool name for `per-tool`. A card's title
+ * counts its calls and its status follows the whole group; with one call
+ * per key that reduces to the plain per-call card.
+ */
+import { redactSecretTokens } from "./redact.js";
+import { truncateCardText } from "./stream.js";
+/** The argument the playground puts in a built-in tool's header. */
+const TOOL_PRIMARY_ARGS = {
+    grep: ["pattern"],
+    glob: ["glob_pattern", "globPattern"],
+    read: ["path", "file_path", "target_file"],
+    shell: ["command", "cmd"],
+    task: ["description", "prompt"],
+};
+/** For other tools: the telling key, if any. */
+const GENERIC_PRIMARY_ARGS = [
+    "pattern",
+    "query",
+    "command",
+    "cmd",
+    "path",
+    "file",
+    "file_path",
+    "target_file",
+    "url",
+    "prompt",
+    "description",
+    "name",
+    "message",
+];
+const PATH_ARGS = new Set([
+    "path",
+    "file",
+    "file_path",
+    "target_file",
+    "target_directory",
+    "targetDirectory",
+]);
+const LINE_MAX = 80;
+const JSON_MAX = 120;
+function oneLine(text, max) {
+    return truncateCardText(redactSecretTokens(text).replace(/\s+/g, " ").trim(), max);
+}
+/** Clamp the middle so both ends stay visible; tail-biased to keep filenames. */
+function clampPath(text, max) {
+    const one = redactSecretTokens(text).replace(/\s+/g, " ").trim();
+    if (one.length <= max) {
+        return one;
+    }
+    const budget = max - 1;
+    const head = Math.max(1, Math.floor(budget * 0.35));
+    const tail = Math.max(1, budget - head);
+    return `${one.slice(0, head)}…${one.slice(one.length - tail)}`;
+}
+/**
+ * Default tool-card line for a call, matching the playground's tool header:
+ * the grep pattern, the glob pattern, the file path, the shell command. Other
+ * tools show a lone string argument bare, else compact JSON. No key labels,
+ * no knobs like `headLimit`.
+ */
+export function defaultToolCardDetails(call) {
+    var _a;
+    var _b;
+    const args = call.args;
+    if (args === undefined || args === null) {
+        return undefined;
+    }
+    if (typeof args === "string") {
+        const line = oneLine(args, LINE_MAX);
+        return line === "" ? undefined : line;
+    }
+    if (typeof args !== "object" || Array.isArray(args)) {
+        return oneLine(JSON.stringify(args), JSON_MAX);
+    }
+    const record = args;
+    for (const key of (_b = TOOL_PRIMARY_ARGS[call.toolName]) !== null && _b !== void 0 ? _b : GENERIC_PRIMARY_ARGS) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim() !== "") {
+            return PATH_ARGS.has(key)
+                ? clampPath(value, LINE_MAX)
+                : oneLine(value, LINE_MAX);
+        }
+    }
+    const entries = Object.entries(record);
+    if (entries.length === 0) {
+        return undefined;
+    }
+    const lone = entries.length === 1 ? (_a = entries[0]) === null || _a === void 0 ? void 0 : _a[1] : undefined;
+    if (typeof lone === "string" && lone.trim() !== "") {
+        return oneLine(lone, LINE_MAX);
+    }
+    return oneLine(JSON.stringify(record), JSON_MAX);
+}
+function tallyFor(state, key) {
+    if (state.toolCardCounts === undefined) {
+        state.toolCardCounts = {};
+    }
+    const existing = state.toolCardCounts[key];
+    if (existing !== undefined) {
+        return existing;
+    }
+    const created = { started: 0, done: 0, errors: 0 };
+    state.toolCardCounts[key] = created;
+    return created;
+}
+/**
+ * Slack appends each update's text to the card verbatim, so a group's later
+ * batch of lines brings its own line break.
+ */
+function appendLines(tally, field, lines) {
+    var _a;
+    if (lines.length === 0) {
+        return undefined;
+    }
+    const already = (_a = tally[field]) !== null && _a !== void 0 ? _a : 0;
+    tally[field] = already + lines.length;
+    return `${already > 0 ? "\n" : ""}${lines.join("\n")}`;
+}
+function present(line) {
+    return line !== undefined && line !== "";
+}
+export function createToolCards(cards, toolLabel) {
+    const keyOf = (call) => cards.group === "per-call" ? call.callId : `tool:${call.toolName}`;
+    const title = (toolName, started) => {
+        const label = toolLabel(toolName);
+        return started > 1 ? `${label} ×${started}` : label;
+    };
+    return {
+        forCalls(state, calls) {
+            var _a;
+            const groups = new Map();
+            for (const call of calls) {
+                const key = keyOf(call);
+                groups.set(key, [...((_a = groups.get(key)) !== null && _a !== void 0 ? _a : []), call]);
+            }
+            return [...groups.entries()].map(([key, group]) => {
+                const tally = tallyFor(state, key);
+                tally.started += group.length;
+                const chunk = {
+                    type: "task_update",
+                    id: key,
+                    title: title(group[0].toolName, tally.started),
+                    status: "in_progress",
+                };
+                const details = appendLines(tally, "details", group.map((call) => { var _a; return (_a = cards.details) === null || _a === void 0 ? void 0 : _a.call(cards, call); }).filter(present));
+                if (details !== undefined) {
+                    chunk.details = details;
+                }
+                return chunk;
+            });
+        },
+        forResult(state, result) {
+            var _a;
+            const tally = tallyFor(state, keyOf(result));
+            tally.done += 1;
+            if (result.isError) {
+                tally.errors += 1;
+            }
+            const chunk = {
+                type: "task_update",
+                id: keyOf(result),
+                title: title(result.toolName, tally.started),
+                status: tally.done < tally.started
+                    ? "in_progress"
+                    : tally.errors > 0
+                        ? "error"
+                        : "complete",
+            };
+            const output = appendLines(tally, "output", [(_a = cards.output) === null || _a === void 0 ? void 0 : _a.call(cards, result)].filter(present));
+            if (output !== undefined) {
+                chunk.output = output;
+            }
+            return chunk;
+        },
+    };
+}