@best-agent/cli 0.0.2-beta.8 → 0.0.3-beta.1

package/dist/dimsdk/core/store/transcript-projector.js

@@ -1,580 +0,0 @@
-import { createLocalThinkingPartId } from "../transcript-part-id.js";
-import { canonicalToolName } from "../tool-metadata.js";
-import { isDelegationRecordedFinalMessage } from "../../compat/runtime-host.js";
-import { t } from "../../i18n/index.js";
-import { readTrimmedString } from "./semantic-readers.js";
-import { buildApprovalRequestFromEvent as buildApprovalRequest, buildToolResultFromEvent as buildToolResult, } from "./agent-event-mappers.js";
-const DEFAULT_ASSISTANT_MARKDOWN_STREAM_ID = "__assistant_markdown__";
-function normalizeText(value) {
-    return readTrimmedString(value) ?? "";
-}
-function asRecord(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return {};
-    return value;
-}
-function extractTextParts(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value
-        .map((part) => {
-        const record = asRecord(part);
-        return typeof record.text === "string" ? record.text : "";
-    })
-        .filter(Boolean);
-}
-function extractTextContent(content) {
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    return extractTextParts(content).join("");
-}
-function compactActivityText(value, max = 80) {
-    const normalized = String(value ?? "")
-        .replace(/\r/g, "")
-        .replace(/\s+/g, " ")
-        .trim();
-    if (!normalized)
-        return "";
-    if (normalized.length <= max)
-        return normalized;
-    if (max <= 1)
-        return normalized.slice(0, max);
-    return `${normalized.slice(0, max - 1).trimEnd()}…`;
-}
-function subagentToolInputSummary(input) {
-    const value = input.file_path ??
-        input.path ??
-        input.query ??
-        input.pattern ??
-        input.command ??
-        input.file ??
-        input.url;
-    if (Array.isArray(value))
-        return value.map((entry) => compactActivityText(entry, 40)).join(", ");
-    return compactActivityText(value, 60);
-}
-function tryParseInputObject(value) {
-    if (value && typeof value === "object" && !Array.isArray(value))
-        return value;
-    if (typeof value !== "string")
-        return null;
-    const text = value.trim();
-    if (!text)
-        return null;
-    try {
-        const parsed = JSON.parse(text);
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
-            return parsed;
-    }
-    catch {
-        return null;
-    }
-    return null;
-}
-function formatSubagentToolActivity(toolName, input) {
-    const name = canonicalToolName(toolName) || normalizeText(toolName);
-    if (!name)
-        return "";
-    const inputObject = tryParseInputObject(input);
-    const rawSummary = compactActivityText(input);
-    const summary = inputObject
-        ? subagentToolInputSummary(inputObject)
-        : rawSummary.startsWith("{") || rawSummary.startsWith("[")
-            ? ""
-            : rawSummary;
-    return compactActivityText(summary ? `${name} ${summary}` : name);
-}
-function hasVisibleReasoningText(value) {
-    return normalizeText(value).length > 0;
-}
-function findAssistant(messages, assistantId) {
-    const message = messages.find((entry) => entry?.id === assistantId);
-    return message?.role === "assistant" ? message : null;
-}
-function hasThinkingBlockWithId(messages, assistantId, partId) {
-    const normalizedPartId = normalizeText(partId);
-    if (!normalizedPartId)
-        return false;
-    const message = findAssistant(messages, assistantId);
-    return Boolean(message?.parts.some((part) => part.type === "thinking" && normalizeText(part.partId) === normalizedPartId));
-}
-function readThinkingBlockContent(messages, assistantId, partId) {
-    const normalizedPartId = normalizeText(partId);
-    if (!normalizedPartId)
-        return undefined;
-    const message = findAssistant(messages, assistantId);
-    const part = message?.parts.find((entry) => entry.type === "thinking" && normalizeText(entry.partId) === normalizedPartId);
-    return part?.type === "thinking" ? String(part.content ?? "") : undefined;
-}
-function readAssistantMarkdownText(messages, assistantId) {
-    const message = findAssistant(messages, assistantId);
-    if (!message)
-        return "";
-    return message.parts
-        .filter((part) => part.type === "markdown")
-        .map((part) => String(part.markdown ?? ""))
-        .join("");
-}
-function hasToolCall(messages, assistantId, callId) {
-    const normalizedCallId = normalizeText(callId);
-    if (!normalizedCallId)
-        return false;
-    const message = findAssistant(messages, assistantId);
-    return Boolean(message?.parts.some((part) => part.type === "tool_call" && normalizeText(part.call.id) === normalizedCallId));
-}
-function removeThinkingBlock(updateAssistant, assistantId, partId) {
-    const normalizedPartId = normalizeText(partId);
-    if (!normalizedPartId)
-        return;
-    updateAssistant(assistantId, (message) => {
-        const parts = message.parts.filter((part) => part.type !== "thinking" || normalizeText(part.partId) !== normalizedPartId);
-        return parts.length === message.parts.length ? message : { ...message, parts };
-    });
-}
-function setSubagentHeaderState(updateAssistant, assistantId, subagentId, state) {
-    const normalizedSubagentId = normalizeText(subagentId);
-    if (!normalizedSubagentId)
-        return;
-    updateAssistant(assistantId, (message) => {
-        const headerIndex = message.parts.findIndex((part) => {
-            const record = asRecord(part);
-            return (part.type === "info" &&
-                record._subagent === "header" &&
-                normalizeText(record._subagentId) === normalizedSubagentId);
-        });
-        if (headerIndex < 0)
-            return message;
-        const parts = message.parts.slice();
-        const header = parts[headerIndex];
-        if (!header || header.type !== "info")
-            return message;
-        const headerWithMeta = header;
-        if (state) {
-            const updatedHeader = { ...headerWithMeta, _subagentState: state };
-            parts[headerIndex] = updatedHeader;
-        }
-        else {
-            const { _subagentState: _ignored, ...rest } = headerWithMeta;
-            parts[headerIndex] = rest;
-        }
-        return { ...message, parts };
-    });
-}
-function isTodoToolName(toolName) {
-    return toolName === "todowrite";
-}
-function isPlanToolName(toolName) {
-    return toolName === "todoplan" || toolName === "plan_mode_todoplan";
-}
-export function createTranscriptProjector(opts) {
-    const stateByAssistantId = new Map();
-    const getAssistantState = (assistantId) => {
-        const existing = stateByAssistantId.get(assistantId);
-        if (existing)
-            return existing;
-        const next = {
-            assistantMarkdownByStreamId: new Map(),
-            placeholderThinkingPartIds: new Set(),
-            projectMarkdownByStreamOrder: false,
-            sawAssistantDelta: false,
-            streamedThinkingContentByPartId: new Map(),
-            toolOutputStarted: new Set(),
-            reusedPlaceholderThinkingContentByPartId: new Map(),
-        };
-        stateByAssistantId.set(assistantId, next);
-        return next;
-    };
-    const replaceAssistantMarkdown = (assistantId, content) => {
-        opts.flushPendingAssistantOutput?.(assistantId);
-        opts.updateAssistant(assistantId, (message) => {
-            const nextParts = message.parts.filter((part) => part.type !== "markdown");
-            return nextParts.length === message.parts.length ? message : { ...message, parts: nextParts };
-        });
-        if (content)
-            opts.appendAssistantMarkdown(assistantId, content);
-    };
-    const markAssistantMarkdownSettled = (assistantId) => {
-        opts.updateAssistant(assistantId, (message) => {
-            let changed = false;
-            const parts = message.parts.map((part) => {
-                if (part.type !== "markdown" ||
-                    Boolean(part._subagentTranscript) ||
-                    part.streamMeta?.settled) {
-                    return part;
-                }
-                changed = true;
-                return {
-                    ...part,
-                    streamMeta: { ...part.streamMeta, settled: true },
-                };
-            });
-            return changed ? { ...message, parts } : message;
-        });
-    };
-    const replaceAssistantMarkdownSnapshot = (assistantId, content) => {
-        const finalContent = String(content ?? "");
-        opts.flushPendingAssistantOutput?.(assistantId);
-        opts.updateAssistant(assistantId, (message) => {
-            const nextParts = message.parts.filter((part) => part.type !== "markdown" || Boolean(part._subagentTranscript));
-            if (finalContent) {
-                nextParts.push({
-                    type: "markdown",
-                    markdown: finalContent,
-                    streamMeta: { settled: true },
-                });
-            }
-            return { ...message, parts: nextParts };
-        });
-    };
-    const renderAssistantMarkdownStreams = (assistantId) => [...getAssistantState(assistantId).assistantMarkdownByStreamId.values()].join("");
-    const appendAssistantMarkdownDelta = (assistantId, delta, streamId) => {
-        const assistantState = getAssistantState(assistantId);
-        const resolvedStreamId = streamId ?? DEFAULT_ASSISTANT_MARKDOWN_STREAM_ID;
-        assistantState.assistantMarkdownByStreamId.set(resolvedStreamId, `${assistantState.assistantMarkdownByStreamId.get(resolvedStreamId) ?? ""}${delta}`);
-        if (assistantState.projectMarkdownByStreamOrder) {
-            replaceAssistantMarkdown(assistantId, renderAssistantMarkdownStreams(assistantId));
-        }
-        else {
-            opts.appendAssistantMarkdown(assistantId, delta);
-        }
-    };
-    const replaceAssistantMarkdownWithFinalMessage = (assistantId, content) => {
-        const finalContent = String(content ?? "");
-        if (!finalContent)
-            return;
-        const previousText = readAssistantMarkdownText(opts.state.messages, assistantId);
-        if (previousText === finalContent) {
-            markAssistantMarkdownSettled(assistantId);
-            return;
-        }
-        const assistantState = getAssistantState(assistantId);
-        assistantState.assistantMarkdownByStreamId.clear();
-        assistantState.assistantMarkdownByStreamId.set(DEFAULT_ASSISTANT_MARKDOWN_STREAM_ID, finalContent);
-        assistantState.projectMarkdownByStreamOrder = false;
-        replaceAssistantMarkdownSnapshot(assistantId, finalContent);
-    };
-    const resetAssistantMarkdown = (assistantId, streamId) => {
-        const assistantState = getAssistantState(assistantId);
-        if (streamId) {
-            if (assistantState.assistantMarkdownByStreamId.has(streamId)) {
-                assistantState.assistantMarkdownByStreamId.set(streamId, "");
-                assistantState.projectMarkdownByStreamOrder = true;
-            }
-        }
-        else if (!streamId) {
-            assistantState.assistantMarkdownByStreamId.clear();
-            assistantState.projectMarkdownByStreamOrder = false;
-        }
-        replaceAssistantMarkdown(assistantId, renderAssistantMarkdownStreams(assistantId));
-        assistantState.sawAssistantDelta = assistantState.assistantMarkdownByStreamId.size > 0;
-    };
-    const findReusablePlaceholderThinkingPartId = (assistantId) => {
-        const assistantState = getAssistantState(assistantId);
-        for (const placeholderPartId of assistantState.placeholderThinkingPartIds) {
-            if (hasThinkingBlockWithId(opts.state.messages, assistantId, placeholderPartId)) {
-                return placeholderPartId;
-            }
-            assistantState.placeholderThinkingPartIds.delete(placeholderPartId);
-        }
-        return undefined;
-    };
-    const retargetThinkingBlockPartId = (assistantId, fromPartId, toPartId) => {
-        const normalizedFromPartId = normalizeText(fromPartId);
-        const normalizedToPartId = normalizeText(toPartId);
-        if (!normalizedFromPartId || !normalizedToPartId)
-            return false;
-        let retargeted = false;
-        opts.updateAssistant(assistantId, (message) => {
-            const parts = message.parts.slice();
-            const fromIndex = parts.findIndex((part) => part.type === "thinking" && normalizeText(part.partId) === normalizedFromPartId);
-            if (fromIndex < 0)
-                return message;
-            if (parts.some((part) => part.type === "thinking" && normalizeText(part.partId) === normalizedToPartId)) {
-                return message;
-            }
-            const previous = parts[fromIndex];
-            if (previous?.type !== "thinking")
-                return message;
-            parts[fromIndex] = { ...previous, partId: normalizedToPartId };
-            retargeted = true;
-            return { ...message, parts };
-        });
-        return retargeted;
-    };
-    const ensureVisibleToolCall = (assistantId, toolCallId, toolName, input = {}, meta) => {
-        const callId = normalizeText(toolCallId);
-        if (!callId)
-            return;
-        if (!hasToolCall(opts.state.messages, assistantId, callId)) {
-            opts.upsertToolCallDelta(assistantId, callId, canonicalToolName(toolName), "", undefined, meta);
-        }
-        opts.upsertToolCallEnd(assistantId, callId, canonicalToolName(toolName), input, undefined, meta);
-    };
-    const appendHiddenSubagentMarkdown = (assistantId, subagentId, turnId, delta) => {
-        const normalizedSubagentId = normalizeText(subagentId);
-        const text = String(delta ?? "");
-        if (!normalizedSubagentId || !text)
-            return;
-        const normalizedTurnId = normalizeText(turnId);
-        const updateHiddenAssistant = opts.updateAssistantHidden ?? opts.updateAssistant;
-        updateHiddenAssistant(assistantId, (message) => {
-            const parts = message.parts.slice();
-            let idx = -1;
-            for (let i = parts.length - 1; i >= 0; i--) {
-                const part = parts[i];
-                if (part?.type === "markdown" &&
-                    part?._subagentTranscript === "text" &&
-                    part?._subagentId === normalizedSubagentId &&
-                    String(part?._subagentTurnId ?? "") === normalizedTurnId) {
-                    idx = i;
-                    break;
-                }
-            }
-            if (idx >= 0) {
-                const prev = parts[idx];
-                if (prev?.type !== "markdown")
-                    return message;
-                parts[idx] = {
-                    ...prev,
-                    markdown: `${prev.markdown}${text}`,
-                    streamMeta: {
-                        ...prev.streamMeta,
-                        appendSeq: Number(prev.streamMeta?.appendSeq ?? 0) + 1,
-                        lastAppendDelta: text,
-                    },
-                };
-                return { ...message, parts };
-            }
-            parts.push({
-                type: "markdown",
-                markdown: text,
-                streamMeta: {
-                    appendSeq: 1,
-                    lastAppendDelta: text,
-                },
-                _subagentId: normalizedSubagentId,
-                _subagentTranscript: "text",
-                ...(normalizedTurnId ? { _subagentTurnId: normalizedTurnId } : {}),
-            });
-            return { ...message, parts };
-        });
-    };
-    return {
-        apply(assistantId, event) {
-            const assistantState = getAssistantState(assistantId);
-            if (event.type === "thinking.started") {
-                if (event.subagentId)
-                    return;
-                const existingLiveBlock = hasThinkingBlockWithId(opts.state.messages, assistantId, event.partId);
-                let reusesPlaceholder = false;
-                if (!existingLiveBlock) {
-                    const reusablePlaceholderPartId = findReusablePlaceholderThinkingPartId(assistantId);
-                    if (reusablePlaceholderPartId) {
-                        const placeholderContent = readThinkingBlockContent(opts.state.messages, assistantId, reusablePlaceholderPartId);
-                        reusesPlaceholder = retargetThinkingBlockPartId(assistantId, reusablePlaceholderPartId, event.partId);
-                        if (reusesPlaceholder) {
-                            assistantState.placeholderThinkingPartIds.delete(reusablePlaceholderPartId);
-                            if (placeholderContent) {
-                                assistantState.reusedPlaceholderThinkingContentByPartId.set(event.partId, placeholderContent);
-                            }
-                        }
-                    }
-                }
-                if (!reusesPlaceholder) {
-                    assistantState.streamedThinkingContentByPartId.set(event.partId, "");
-                }
-                return;
-            }
-            if (event.type === "thinking.delta") {
-                if (event.subagentId)
-                    return;
-                const nextThinking = `${assistantState.streamedThinkingContentByPartId.get(event.partId) ?? ""}${event.delta}`;
-                assistantState.streamedThinkingContentByPartId.set(event.partId, nextThinking);
-                const reusedPlaceholderContent = assistantState.reusedPlaceholderThinkingContentByPartId.get(event.partId);
-                const resolvedThinking = reusedPlaceholderContent?.startsWith(nextThinking)
-                    ? reusedPlaceholderContent
-                    : nextThinking;
-                if (resolvedThinking !== reusedPlaceholderContent) {
-                    assistantState.reusedPlaceholderThinkingContentByPartId.delete(event.partId);
-                }
-                if (!hasVisibleReasoningText(resolvedThinking))
-                    return;
-                if (!hasThinkingBlockWithId(opts.state.messages, assistantId, event.partId)) {
-                    opts.startNewThinkingBlock(assistantId, event.partId);
-                }
-                opts.setAssistantThinking(assistantId, resolvedThinking, event.partId);
-                return;
-            }
-            if (event.type === "thinking.finished") {
-                if (event.subagentId)
-                    return;
-                const finalThinking = typeof event.content === "string"
-                    ? event.content
-                    : assistantState.streamedThinkingContentByPartId.get(event.partId);
-                assistantState.streamedThinkingContentByPartId.delete(event.partId);
-                assistantState.reusedPlaceholderThinkingContentByPartId.delete(event.partId);
-                if (!hasVisibleReasoningText(finalThinking)) {
-                    removeThinkingBlock(opts.updateAssistant, assistantId, event.partId);
-                    return;
-                }
-                if (!hasThinkingBlockWithId(opts.state.messages, assistantId, event.partId)) {
-                    opts.startNewThinkingBlock(assistantId, event.partId);
-                }
-                opts.setAssistantThinking(assistantId, finalThinking ?? "", event.partId);
-                opts.endThinkingBlock(assistantId, event.partId, finalThinking);
-                return;
-            }
-            if (event.type === "assistant.delta") {
-                if (isDelegationRecordedFinalMessage(event.delta))
-                    return;
-                assistantState.sawAssistantDelta = true;
-                appendAssistantMarkdownDelta(assistantId, event.delta, event.streamId);
-                return;
-            }
-            if (event.type === "assistant.reset") {
-                resetAssistantMarkdown(assistantId, event.streamId);
-                return;
-            }
-            if (event.type === "assistant.message") {
-                if (typeof event.message.thinking === "string") {
-                    const thinking = event.message.thinking;
-                    const hasThinkingPart = Boolean(findAssistant(opts.state.messages, assistantId)?.parts.some((part) => part.type === "thinking"));
-                    if (!hasThinkingPart && hasVisibleReasoningText(thinking)) {
-                        const partId = createLocalThinkingPartId(assistantId, 0);
-                        opts.startNewThinkingBlock(assistantId, partId);
-                        opts.setAssistantThinking(assistantId, thinking, partId);
-                        opts.endThinkingBlock(assistantId, partId, thinking);
-                        assistantState.placeholderThinkingPartIds.add(partId);
-                    }
-                }
-                const content = extractTextContent(event.message.content);
-                if (content && !isDelegationRecordedFinalMessage(content)) {
-                    if (assistantState.sawAssistantDelta)
-                        replaceAssistantMarkdownWithFinalMessage(assistantId, content);
-                    else
-                        replaceAssistantMarkdownSnapshot(assistantId, content);
-                }
-                return;
-            }
-            if (event.type === "tool.started") {
-                if (event.subagentId) {
-                    const activity = formatSubagentToolActivity(event.toolName, event.input);
-                    if (activity)
-                        opts.upsertSubagentInfo(assistantId, event.subagentId, "activity", activity, {
-                            subagentStream: "tool",
-                            subagentTurnId: event.subagentTurnId,
-                        });
-                    return;
-                }
-                const meta = event.subagentTurnId || typeof event.startedAtMs === "number"
-                    ? {
-                        subagentTurnId: event.subagentTurnId,
-                        startedAtMs: event.startedAtMs,
-                    }
-                    : undefined;
-                ensureVisibleToolCall(assistantId, event.toolCallId, event.toolName, event.input, meta);
-                return;
-            }
-            if (event.type === "tool.delta") {
-                if (event.subagentId)
-                    return;
-                const meta = event.subagentTurnId ? { subagentTurnId: event.subagentTurnId } : undefined;
-                if (event.kind === "input") {
-                    if (!hasToolCall(opts.state.messages, assistantId, event.toolCallId)) {
-                        opts.upsertToolCallDelta(assistantId, event.toolCallId, event.toolName, "", event.linesWritten, meta);
-                    }
-                    opts.upsertToolCallDelta(assistantId, event.toolCallId, event.toolName, event.delta, event.linesWritten, meta);
-                    return;
-                }
-                const toolName = normalizeText(event.toolName) || event.toolCallId;
-                if (!assistantState.toolOutputStarted.has(event.toolCallId)) {
-                    assistantState.toolOutputStarted.add(event.toolCallId);
-                    opts.upsertToolOutputStart(assistantId, event.toolCallId, toolName, meta);
-                }
-                opts.appendToolOutputDelta(assistantId, event.toolCallId, toolName, event.delta, meta);
-                return;
-            }
-            if (event.type === "tool.finished") {
-                if (event.subagentId) {
-                    assistantState.toolOutputStarted.delete(event.toolCallId);
-                    if (event.isError) {
-                        const name = canonicalToolName(event.toolName) || normalizeText(event.toolName) || "tool";
-                        opts.upsertSubagentInfo(assistantId, event.subagentId, "activity", `${name} error`, {
-                            subagentStream: "error",
-                            subagentTurnId: event.subagentTurnId,
-                        });
-                    }
-                    return;
-                }
-                const result = buildToolResult(event);
-                opts.attachToolResultPart(assistantId, result);
-                opts.scheduleToolResultHighlight?.(assistantId, result);
-                const toolNameLower = normalizeText(event.toolName).toLowerCase();
-                if (result.structuredContent && opts.upsertChecklistPartFromDimSdk) {
-                    if (isTodoToolName(toolNameLower)) {
-                        opts.upsertChecklistPartFromDimSdk(assistantId, "todo", event.toolCallId, result.structuredContent);
-                    }
-                    else if (isPlanToolName(toolNameLower)) {
-                        opts.upsertChecklistPartFromDimSdk(assistantId, "plan", event.toolCallId, result.structuredContent);
-                    }
-                }
-                return;
-            }
-            if (event.type === "action.required" && event.kind === "tool_approval") {
-                ensureVisibleToolCall(assistantId, event.toolCallId, event.toolName, event.args ?? {}, event.subagentId
-                    ? { subagentId: event.subagentId, subagentTurnId: event.subagentTurnId }
-                    : undefined);
-                opts.insertApprovalPart(assistantId, buildApprovalRequest(event));
-                opts.setAssistantStatus(assistantId, t("chatStatus.awaitingApproval"));
-                return;
-            }
-            if (event.type === "action.required" && event.kind === "ask_user") {
-                if (!hasToolCall(opts.state.messages, assistantId, event.toolCallId ?? "")) {
-                    ensureVisibleToolCall(assistantId, event.toolCallId, event.toolName, {});
-                }
-                opts.setAssistantStatus(assistantId, t("chatStatus.awaitingAnswers"));
-                return;
-            }
-            if (event.type === "subagent.started") {
-                const desc = normalizeText(event.taskDescription) || normalizeText(event.subagentId);
-                if (desc)
-                    opts.upsertSubagentInfo(assistantId, event.subagentId, "header", desc);
-                return;
-            }
-            if (event.type === "subagent.output") {
-                const label = normalizeText(event.delta);
-                if (event.stream === "error") {
-                    appendHiddenSubagentMarkdown(assistantId, event.subagentId, event.subagentTurnId, event.transcriptDelta ?? event.delta);
-                }
-                if (label && event.stream !== "text")
-                    opts.upsertSubagentInfo(assistantId, event.subagentId, "activity", label, {
-                        subagentStream: event.stream,
-                        subagentTurnId: event.subagentTurnId,
-                    });
-                return;
-            }
-            if (event.type === "subagent.state") {
-                if (event.state === "paused") {
-                    setSubagentHeaderState(opts.updateAssistant, assistantId, event.subagentId, "paused");
-                    return;
-                }
-                setSubagentHeaderState(opts.updateAssistant, assistantId, event.subagentId, undefined);
-                return;
-            }
-            if (event.type === "subagent.finished") {
-                const stateLabel = event.state === "completed" ? "done" : event.state;
-                opts.upsertSubagentInfo(assistantId, event.subagentId, "finished", stateLabel);
-                return;
-            }
-            if (event.type === "error.recorded") {
-                opts.appendAssistantMarkdown(assistantId, ["# Error", "", "```text", event.message, "```"].join("\n"));
-            }
-        },
-        clearAssistant(assistantId) {
-            stateByAssistantId.delete(assistantId);
-        },
-    };
-}
-//# sourceMappingURL=transcript-projector.js.map

package/dist/dimsdk/core/tool-metadata.d.ts

@@ -1,12 +0,0 @@
-export type ToolSemantic = "ask_user" | "delegate" | "fetch_like" | "other" | "read_like" | "search_like" | "shell_like" | "write_like";
-export declare function canonicalToolName(rawName: unknown): string;
-export declare function toolSemantic(rawName: unknown): ToolSemantic;
-export declare function toolDisplayLabel(rawName: unknown): string;
-export declare function isAskUserToolName(rawName: unknown): boolean;
-export declare function isDelegateToolName(rawName: unknown): boolean;
-export declare function isShellLikeToolName(rawName: unknown): boolean;
-export declare function isFetchLikeToolName(rawName: unknown): boolean;
-export declare function isReadLikeToolName(rawName: unknown): boolean;
-export declare function isSearchLikeToolName(rawName: unknown): boolean;
-export declare function isWriteLikeToolName(rawName: unknown): boolean;
-//# sourceMappingURL=tool-metadata.d.ts.map

package/dist/dimsdk/core/tool-metadata.js

@@ -1,70 +0,0 @@
-const TOOL_ALIAS_MAP = {
-    ask_user: "ask-user",
-    askuserquestion: "ask-user",
-    contentsearch: "content-search",
-    glob: "workspace-search",
-    grep: "content-search",
-    read: "read-file",
-    websearch: "web-search",
-    webfetch: "fetch-url",
-};
-function normalizeText(value) {
-    return typeof value === "string" ? value.trim().toLowerCase() : "";
-}
-export function canonicalToolName(rawName) {
-    const normalized = normalizeText(rawName);
-    if (!normalized)
-        return "";
-    return TOOL_ALIAS_MAP[normalized] ?? normalized;
-}
-export function toolSemantic(rawName) {
-    switch (canonicalToolName(rawName)) {
-        case "ask-user":
-            return "ask_user";
-        case "delegate_tasks":
-            return "delegate";
-        case "shell":
-            return "shell_like";
-        case "fetch-url":
-            return "fetch_like";
-        case "read-file":
-            return "read_like";
-        case "content-search":
-        case "workspace-search":
-        case "web-search":
-            return "search_like";
-        case "write-artifact":
-        case "write-scratch":
-        case "write-workspace":
-        case "edit":
-        case "apply_patch":
-            return "write_like";
-        default:
-            return "other";
-    }
-}
-export function toolDisplayLabel(rawName) {
-    return canonicalToolName(rawName);
-}
-export function isAskUserToolName(rawName) {
-    return toolSemantic(rawName) === "ask_user";
-}
-export function isDelegateToolName(rawName) {
-    return toolSemantic(rawName) === "delegate";
-}
-export function isShellLikeToolName(rawName) {
-    return toolSemantic(rawName) === "shell_like";
-}
-export function isFetchLikeToolName(rawName) {
-    return toolSemantic(rawName) === "fetch_like";
-}
-export function isReadLikeToolName(rawName) {
-    return toolSemantic(rawName) === "read_like";
-}
-export function isSearchLikeToolName(rawName) {
-    return toolSemantic(rawName) === "search_like";
-}
-export function isWriteLikeToolName(rawName) {
-    return toolSemantic(rawName) === "write_like";
-}
-//# sourceMappingURL=tool-metadata.js.map

package/dist/dimsdk/core/transcript-part-id.d.ts

@@ -1,6 +0,0 @@
-export declare function createLocalInteractivePartId(kind: 'thinking' | 'todo' | 'plan', ownerId: string, blockOrdinal: number): string;
-export declare function createThinkingPartIdFromReasoningItem(itemId: string): string;
-export declare function createThinkingPartIdFromStream(turnId: string, streamId: string): string;
-export declare function createLocalThinkingPartId(ownerId: string, blockOrdinal: number): string;
-export declare function createChecklistPartId(kind: 'todo' | 'plan', toolCallId: string): string;
-//# sourceMappingURL=transcript-part-id.d.ts.map