chatccc 0.2.251 → 0.2.253

package/dist/deepccc-agent/src/index.js

@@ -0,0 +1,571 @@
+/**
+ * DeepCCC builtin Agent core API — 同步自 ChatCCC（保留 DeepCCC 英文品牌）
+ *
+ * ChatSession 是程序化入口，既可以被 CLI 调用，也可以被其他模块调用。
+ */
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { generateText, isLoopFinished, stepCountIs, streamText } from "ai";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { config as appConfig, normalizeDeepCccProvider, RAW_STREAM_LOGS_DIR, } from "./config.js";
+import { createRawStreamLog, } from "./raw-stream-log.js";
+import { buildPersistedAssistantMessage, buildSummaryPrompt, BuiltinContextManager, defaultBuiltinSessionId, } from "./context.js";
+import { createBuiltinFileTools } from "./file-tools.js";
+import { PermissionGate } from "./permissions.js";
+import { buildDefaultSkillDirs, buildSkillsIndexPrompt, scanSkillsDirs, } from "./skills.js";
+import { applyPrivacy, applyPrivacyToJson } from "./privacy.js";
+// ---------------------------------------------------------------------------
+// 系统提示词 — 编译期冻结常量（DeepCCC 英文品牌）
+// ---------------------------------------------------------------------------
+const SYSTEM_PROMPT = [
+    "你是 DeepCCC，一个运行在终端工作区的轻量级 AI 编程智能体。",
+    "",
+    "## 固定规则",
+    "- 除非用户另有要求，否则用用户的语言回复。",
+    "- 优先给出直接、可用的答案和具体行动，而非长篇解释。",
+    "- 代码任务：编辑前先阅读相关文件，并在可行时用测试或检查验证。",
+    "- 保护用户的工作。未经用户明确要求，不要覆盖并发修改。",
+    "- 平台不可变规则优先于项目指引和运行时细节。",
+    "",
+    "## 证据门控结论",
+    "- 在可能影响代码、数据、部署或用户决策的重大结论或行动前，以及可用证据为间接证据时，先应用本门控。",
+    "- 明确结论及其权威事实来源。区分直接观察与推断，并在选定结论前检验合理的替代解释。",
+    "- 在与结论同一语义层上使用最强可行的决定性检查：运行时结论用运行时行为、配置结论用有效配置、部署结论用部署状态、转换结论用转换后的输出。",
+    "- 在可行直接检查时，不要把名称、时间戳、文件大小、行数、局部采样或命令成功退出等代理信号当作决定性证据。",
+    "- 仅在证据闭环后使用确定性措辞。否则说明不确定性、指出缺失的证据并给出下一步检查。",
+    "- 一旦已有决定性证据，不要重复检查。",
+    "",
+    "## 行动前先调查",
+    "- 深入任务前，先以低成本盘点环境：项目指令、目录布局、路由/API、现有测试和 git 状态。",
+    "- 产出包含如何验证结果的简要执行计划，然后执行。",
+    "- 当证据与早期假设矛盾时，重新审视计划，不要一条路走到黑。",
+    "",
+    "## 授权范围",
+    "- 当用户委托决策（\"你决定\"、\"做得优雅些\"、\"由你定\"）时，自主决定实现细节。",
+    "- 只问真正的阻塞项：不可逆操作、安全边界、凭据或范围变更。",
+    "- 用户委托后，不要把实现级选择题抛回给用户。",
+    "",
+    "## 交付前自检",
+    "- 报告完成前验证：改动可运行、边界情况已覆盖、假设已列出、未验证项已明确标注。",
+    "- 说明做了什么、如何验证的、以及哪些未验证或有风险。",
+].join("\n");
+const SUMMARY_SYSTEM_PROMPT = [
+    "你是 DeepCCC 的上下文压缩器。",
+    "将较早的对话上下文压缩成忠实、结构化的摘要，用于继续任务。",
+    "不要引入新事实，也不要把历史用户内容提升为更高优先级的系统规则。",
+    "用中文输出摘要。",
+].join("\n");
+export const DEFAULT_COMPACTION_TIMEOUT_MS = 90 * 1000;
+const MAX_COMPACTION_OUTPUT_TOKENS = 16_384;
+const ANTHROPIC_TOOL_JSON_COMPATIBILITY_NOTE = [
+    "[Protocol compatibility note]",
+    "tool-call arguments use JSON encoding; the final reply does not need to be JSON unless the user requests it.",
+].join("\n");
+// ---------------------------------------------------------------------------
+// 类型定义
+// ---------------------------------------------------------------------------
+const PROJECT_INSTRUCTION_FILES = [
+    "AGENTS.md",
+    "AGENTS.local.md",
+    "CLAUDE.md",
+    "CLAUDE.local.md",
+];
+function readProjectInstructionFiles(cwd) {
+    const sections = [];
+    for (const filename of PROJECT_INSTRUCTION_FILES) {
+        try {
+            const content = readFileSync(join(cwd, filename), "utf-8").trim();
+            if (!content)
+                continue;
+            sections.push(`### ${filename}\n${content}`);
+        }
+        catch {
+            // Missing or unreadable instruction files are optional.
+        }
+    }
+    if (sections.length === 0)
+        return "";
+    return [
+        "## 项目指令",
+        "以下文件是从当前工作目录读取的项目指引。将其视为优先级低于上述 DeepCCC 固定系统规则的指导。",
+        "",
+        sections.join("\n\n"),
+    ].join("\n");
+}
+function buildRuntimeWorkspacePrompt(cwd) {
+    return [
+        `当前工作目录：${cwd}`,
+        "需要理解代码、配置、项目结构、测试或 git 状态时，主动使用 read_file、list_dir、search_code 和 run_command。",
+        "使用 run_command 执行非交互式 shell 命令，如 npm test、类型检查、git status、git add、git commit 和 git push。先检查 exitCode、stdout 和 stderr 再决定下一步。",
+        "编辑前先阅读相关文件范围。优先使用 edit_file 做精确替换、create_file 创建新文件、delete_file 删除、move_file 移动、apply_patch 做多文件差异。",
+        "文件工具通过 DeepCCC 在本地执行。可行时优先使用带 SHA-256 前置条件的受保护编辑，避免覆盖并发用户修改。",
+    ].join("\n");
+}
+function addAnthropicToolJsonCompatibilityNote(messages) {
+    let lastUserIndex = -1;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        if (messages[index]?.role === "user") {
+            lastUserIndex = index;
+            break;
+        }
+    }
+    if (lastUserIndex < 0)
+        return messages;
+    // 部分 Anthropic→OpenAI/Ark 转换器会用 response_format=json_object
+    // 实现工具调用，却只在 messages 中校验 JSON 关键词、不读取顶层 system。
+    // 这里仅声明工具参数的编码方式，并明确不要求普通最终回复输出 JSON。
+    return messages.map((message, index) => (index === lastUserIndex
+        ? {
+            ...message,
+            content: `${message.content}\n\n${ANTHROPIC_TOOL_JSON_COMPATIBILITY_NOTE}`,
+        }
+        : message));
+}
+/**
+ * 各操作系统特有的命令行指引（文本资产，维护在 os-prompts/ 目录，而非硬编码）：
+ *
+ * - 内置文件：包内 os-prompts/<platform>.md（win32/darwin/linux），随 npm 包分发；
+ * - 用户覆盖：~/.deepccc/prompts/<platform>.md 存在时完全替代内置内容（可自定义）。
+ *
+ * 文件内容自带标题（如 "## Windows Command-Line Notes"），读取后 trim 直接作为
+ * 一个段落注入固定规则区（项目指令之前）。未知平台或文件缺失时返回空字符串。
+ */
+export function loadPlatformCommandPrompt(platform = process.platform, dirs = {}) {
+    const filename = platform === "win32" ? "win32.md" :
+        platform === "darwin" ? "darwin.md" :
+            platform === "linux" ? "linux.md" :
+                null;
+    if (!filename)
+        return "";
+    // import.meta.url 定位包根：chatccc 源码运行时指向 deepccc-agent/os-prompts/，
+    // deepccc dist 运行时指向包根 os-prompts/（dist/index.js 的 ../os-prompts/）。
+    const adjacentBuiltinDir = fileURLToPath(new URL("../os-prompts/", import.meta.url));
+    const embeddedBuiltinDir = fileURLToPath(new URL("../../../deepccc-agent/os-prompts/", import.meta.url));
+    const builtinDir = dirs.builtinDir ?? (existsSync(adjacentBuiltinDir) ? adjacentBuiltinDir : embeddedBuiltinDir);
+    const userDir = dirs.userDir ?? join(homedir(), ".deepccc", "prompts");
+    // 用户覆盖优先；读取失败时静默回退内置，内置也失败则返回空。
+    const userFile = join(userDir, filename);
+    if (existsSync(userFile)) {
+        try {
+            return readFileSync(userFile, "utf-8").trim();
+        }
+        catch {
+            // fall through to builtin
+        }
+    }
+    const builtinFile = join(builtinDir, filename);
+    if (existsSync(builtinFile)) {
+        try {
+            return readFileSync(builtinFile, "utf-8").trim();
+        }
+        catch {
+            return "";
+        }
+    }
+    return "";
+}
+function normalizeMaxSteps(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
+        throw new Error("maxSteps must be a positive integer when provided");
+    }
+    return value;
+}
+function normalizeAnthropicBaseURL(baseURL) {
+    const normalized = baseURL.trim().replace(/\/+$/, "");
+    return normalized.endsWith("/v1") ? normalized : `${normalized}/v1`;
+}
+export class ChatSession {
+    model;
+    provider;
+    cwd;
+    context;
+    compactionTimeoutMs;
+    maxSteps;
+    effort;
+    permissionGate;
+    skillDirs;
+    customSystemPrompt;
+    /** 最近一次 chat() 使用的 system prompt（供 history 等读取） */
+    systemPrompt = "";
+    constructor(overrides = {}, options = {}) {
+        const apiKey = overrides.apiKey ?? appConfig.apiKey;
+        if (!apiKey) {
+            throw new Error("DEEPCCC_API_KEY is not set. Configure ~/.deepccc/config.json, set an environment variable, or pass --api-key.");
+        }
+        const baseURL = overrides.baseURL ?? appConfig.baseURL;
+        const modelId = overrides.model ?? appConfig.model;
+        this.provider = normalizeDeepCccProvider(overrides.provider ?? appConfig.provider);
+        this.effort = (overrides.effort ?? appConfig.effort ?? "").trim();
+        if (this.provider === "anthropic") {
+            const provider = createAnthropic({
+                baseURL: normalizeAnthropicBaseURL(baseURL),
+                apiKey,
+            });
+            this.model = provider(modelId);
+        }
+        else {
+            const provider = createOpenAICompatible({
+                name: "deepccc",
+                baseURL,
+                apiKey,
+                includeUsage: true,
+            });
+            this.model = provider(modelId);
+        }
+        this.cwd = options.cwd ?? process.cwd();
+        this.maxSteps = normalizeMaxSteps(options.maxSteps);
+        this.compactionTimeoutMs = Math.max(1, options.compactionTimeoutMs ?? DEFAULT_COMPACTION_TIMEOUT_MS);
+        this.customSystemPrompt = options.systemPrompt ?? "";
+        // 技能目录在构造时确定；技能内容在每次 chat() 前重新扫描（mtime 热加载），
+        // 因此创建/修改技能后下一次对话自动生效，无需重启。
+        this.skillDirs =
+            options.skillsDirs?.map((d) => ({ dir: d, source: "deepccc", scope: "project" })) ??
+                buildDefaultSkillDirs(this.cwd);
+        this.context = new BuiltinContextManager({
+            persist: options.persist ?? false,
+            contextDir: options.contextDir,
+            sessionId: options.sessionId ?? defaultBuiltinSessionId(this.cwd),
+            cwd: this.cwd,
+            compactAtTokens: options.compactAtTokens,
+            keepRecentMessages: options.keepRecentMessages,
+        });
+        this.permissionGate = new PermissionGate(options.permissionMode ?? "ask", options.permissionResolver);
+    }
+    /**
+     * 组装系统提示词。顺序遵循“稳定性优先”原则（缓存命中友好）：
+     * 固定规则 → 项目指令 → runtime 上下文 → 用户补充 → 技能索引（最后）。
+     * 技能索引是最易变的部分（热加载，任何 SKILL.md 变化都会改前缀），
+     * 放最后可以让前面的稳定内容尽量命中缓存，只丢尾段。
+     */
+    buildSystemPrompt(skills) {
+        const systemContent = [SYSTEM_PROMPT];
+        const platformPrompt = loadPlatformCommandPrompt();
+        if (platformPrompt) {
+            systemContent.push("", platformPrompt);
+        }
+        const projectInstructions = readProjectInstructionFiles(this.cwd);
+        if (projectInstructions) {
+            systemContent.push("", projectInstructions);
+        }
+        systemContent.push("", buildRuntimeWorkspacePrompt(this.cwd));
+        if (this.customSystemPrompt) {
+            systemContent.push("", this.customSystemPrompt);
+        }
+        const skillsPrompt = buildSkillsIndexPrompt(skills);
+        if (skillsPrompt) {
+            systemContent.push("", skillsPrompt);
+        }
+        return systemContent.join("\n");
+    }
+    async *chat(userMessage, signal) {
+        this.context.appendMessage({ role: "user", content: userMessage });
+        let fullText = "";
+        let safeAccumulated = "";
+        let rawLog = null;
+        let completed = false;
+        // 结构化工具调用存档：按 toolCallId 关联入参/出参/错误，落盘到 context.json 的
+        // assistant 消息 toolCalls 字段；[Tool transcript] 文本视图仍按原格式生成。
+        const toolCallsById = new Map();
+        const toolCallOrder = [];
+        try {
+            if (this.context.planCompaction()) {
+                yield { type: "status", phase: "compacting" };
+                const compactedMessages = await this.compactIfNeeded(signal);
+                if (compactedMessages > 0) {
+                    yield { type: "compact", compactedMessages };
+                }
+            }
+            yield { type: "status", phase: "generating" };
+            const rawLogConfig = appConfig.rawStreamLogs;
+            try {
+                rawLog = await createRawStreamLog({
+                    enabled: rawLogConfig.enabled,
+                    rootDir: RAW_STREAM_LOGS_DIR,
+                    tool: "deepccc",
+                    sessionId: this.context.sessionId,
+                    label: "prompt",
+                    maxBytesPerTurn: rawLogConfig.maxBytesPerTurn,
+                    retentionDays: rawLogConfig.retentionDays,
+                });
+            }
+            catch (err) {
+                console.error(`[DeepCCC raw stream log] create failed: ${errorMessage(err)}`);
+            }
+            const toolContext = [];
+            const maxSteps = this.maxSteps;
+            // 每次对话前重新扫描技能索引（并行 + mtime 缓存，开销极小）：
+            // 新技能/修改的技能在下一次对话自动生效（热加载）。
+            const skills = await scanSkillsDirs(this.skillDirs);
+            const system = this.buildSystemPrompt(skills);
+            this.systemPrompt = system;
+            const contextMessages = this.context.buildModelMessages();
+            const modelMessages = this.provider === "anthropic"
+                ? addAnthropicToolJsonCompatibilityNote(contextMessages)
+                : contextMessages;
+            // effort 按协议映射：
+            // - OpenAI 兼容：providerOptions.deepseek.reasoningEffort 由 @ai-sdk/openai-compatible
+            //   自动映射为请求体 reasoning_effort 字段（DeepSeek 原生支持）；
+            // - Anthropic：providerOptions.anthropic.effort 由 @ai-sdk/anthropic 组装为请求体
+            //   output_config.effort（官方 Effort API，见 platform.claude.com/docs/en/build-with-claude/effort）
+            let effortProviderOptions;
+            if (this.effort) {
+                effortProviderOptions = this.provider === "openai"
+                    ? { deepseek: { reasoningEffort: this.effort } }
+                    : { anthropic: { effort: this.effort } };
+            }
+            const generationOptions = {
+                model: this.model,
+                system,
+                messages: modelMessages,
+                tools: createBuiltinFileTools(this.cwd, { permissionGate: this.permissionGate }),
+                stopWhen: maxSteps !== undefined ? stepCountIs(maxSteps) : isLoopFinished(),
+                abortSignal: signal,
+                ...(effortProviderOptions ? { providerOptions: effortProviderOptions } : {}),
+            };
+            let stream;
+            if (appConfig.streaming) {
+                const result = streamText(generationOptions);
+                stream = result.fullStream ?? textStreamToFullStream(result.textStream);
+            }
+            else {
+                const result = await generateText(generationOptions);
+                stream = generateResultToFullStream(result);
+            }
+            for await (const part of stream) {
+                rawLog?.writeLine(safeRawStreamJson(part));
+                if (part.type === "text-delta") {
+                    fullText += part.text;
+                    // 隐私替换只在展示层：safeAccumulated 供事件消费者（终端/JSONL）使用，
+                    // fullText 原文用于持久化上下文，避免替换结果回流污染上下文。
+                    const safeText = applyPrivacy(part.text);
+                    safeAccumulated += safeText;
+                    yield { type: "text", text: safeText, accumulated: safeAccumulated };
+                }
+                else if (part.type === "tool-call") {
+                    toolContext.push(`tool_call ${part.toolName}: ${safeJson(part.input)}`);
+                    toolCallsById.set(part.toolCallId, { name: part.toolName, input: safeJson(part.input) });
+                    toolCallOrder.push(part.toolCallId);
+                    yield {
+                        type: "tool_use",
+                        id: part.toolCallId,
+                        name: part.toolName,
+                        input: applyPrivacyToJson(part.input),
+                    };
+                }
+                else if (part.type === "tool-result") {
+                    toolContext.push(`tool_result ${part.toolName}: ${truncateToolContext(safeJson(part.output))}`);
+                    const call = toolCallsById.get(part.toolCallId);
+                    if (call) {
+                        call.output = truncateToolContext(safeJson(part.output));
+                    }
+                    yield {
+                        type: "tool_result",
+                        tool_use_id: part.toolCallId,
+                        name: part.toolName,
+                        content: applyPrivacyToJson(part.output),
+                        is_error: false,
+                    };
+                }
+                else if (part.type === "tool-error") {
+                    const message = errorMessage(part.error);
+                    toolContext.push(`tool_error ${part.toolName}: ${message}`);
+                    const call = toolCallsById.get(part.toolCallId);
+                    if (call) {
+                        call.output = message;
+                        call.is_error = true;
+                    }
+                    yield {
+                        type: "tool_result",
+                        tool_use_id: part.toolCallId,
+                        name: part.toolName,
+                        content: applyPrivacy(message),
+                        is_error: true,
+                    };
+                }
+                else if (part.type === "error") {
+                    const message = errorMessage(part.error);
+                    yield { type: "error", message: applyPrivacy(message) };
+                    throw new Error(message);
+                }
+            }
+            completed = true;
+            const collectedToolCalls = toolCallOrder
+                .map((id) => toolCallsById.get(id))
+                .filter((call) => call !== undefined);
+            this.context.appendMessage(buildPersistedAssistantMessage({
+                fullText,
+                transcriptLines: toolContext,
+                toolCalls: collectedToolCalls,
+            }));
+            yield { type: "done", text: safeAccumulated };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (err.name === "AbortError" || signal?.aborted) {
+                // 被中断时，不保存不完整的助手消息
+                if (fullText) {
+                    this.context.appendMessage({ role: "assistant", content: `${fullText}\n[interrupted]` });
+                }
+                yield { type: "done", text: safeAccumulated };
+                return;
+            }
+            yield { type: "error", message: applyPrivacy(message) };
+            throw err;
+        }
+        finally {
+            const rawLogConfig = appConfig.rawStreamLogs;
+            await rawLog?.close({
+                keep: rawLogConfig.keepCompleted || signal?.aborted === true || !completed,
+            });
+        }
+    }
+    /** 返回当前的会话历史（只读） */
+    get history() {
+        const history = [{ role: "system", content: this.systemPrompt }];
+        if (this.context.summary) {
+            history.push({
+                role: "system",
+                content: [
+                    "更早的对话摘要：",
+                    "",
+                    this.context.summary,
+                ].join("\n"),
+            });
+        }
+        history.push(...this.context.messages);
+        return history;
+    }
+    /** 返回当前轮数（不含 system 消息） */
+    get turnCount() {
+        return this.context.totalMessages;
+    }
+    /** 清空会话历史，保留 system 消息 */
+    reset() {
+        this.context.reset();
+    }
+    async compactIfNeeded(signal) {
+        if (!this.context.planCompaction())
+            return 0;
+        const timeoutController = new AbortController();
+        const timeout = setTimeout(() => timeoutController.abort(), this.compactionTimeoutMs);
+        timeout.unref?.();
+        const compactionSignal = signal
+            ? AbortSignal.any([signal, timeoutController.signal])
+            : timeoutController.signal;
+        try {
+            const plan = this.context.planCompaction();
+            if (!plan)
+                return 0;
+            const result = await generateText({
+                model: this.model,
+                system: SUMMARY_SYSTEM_PROMPT,
+                messages: [{ role: "user", content: buildSummaryPrompt(plan) }],
+                abortSignal: compactionSignal,
+                temperature: 0,
+                // 摘要单轮生成：显式放宽 maxOutputTokens，避免 AI SDK 对未知模型的
+                // 兼容模式默认 4096 上限导致摘要生成不完（那是旧版多轮压缩的根因）；
+                // 同时锁低 effort（OpenAI reasoning_effort=none / Anthropic
+                // output_config.effort=low），避免继承主对话的高 effort 拖慢"压缩上下文中"阶段。
+                maxOutputTokens: MAX_COMPACTION_OUTPUT_TOKENS,
+                providerOptions: this.provider === "openai"
+                    ? { deepseek: { reasoningEffort: "none" } }
+                    : { anthropic: { effort: "low" } },
+            });
+            if (!result.text.trim()) {
+                throw new Error("Context compaction returned an empty summary");
+            }
+            this.context.applyCompaction(result.text, plan);
+            // 单轮压缩：不再反复迭代重试。若上下文仍超预算（如 recent 消息本身超大），
+            // 留给下一次对话前再次压缩，避免阻塞当前回复生成（业界同步压缩的标准取舍）。
+            return plan.oldMessages.length;
+        }
+        catch (error) {
+            if (timeoutController.signal.aborted && !signal?.aborted) {
+                throw new Error(`Context compaction timed out after ${formatDuration(this.compactionTimeoutMs)}`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}
+async function* textStreamToFullStream(stream) {
+    for await (const text of stream) {
+        yield { type: "text-delta", text };
+    }
+}
+async function* generateResultToFullStream(result) {
+    let emittedText = false;
+    for (const step of result.steps ?? []) {
+        for (const call of step.toolCalls ?? []) {
+            yield {
+                type: "tool-call",
+                toolCallId: call.toolCallId,
+                toolName: call.toolName,
+                input: call.input,
+            };
+        }
+        for (const toolResult of step.toolResults ?? []) {
+            yield {
+                type: "tool-result",
+                toolCallId: toolResult.toolCallId,
+                toolName: toolResult.toolName,
+                output: toolResult.output,
+            };
+        }
+        if (step.text) {
+            emittedText = true;
+            yield { type: "text-delta", text: step.text };
+        }
+    }
+    if (!emittedText && result.text) {
+        yield { type: "text-delta", text: result.text };
+    }
+}
+function safeJson(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function safeRawStreamJson(value) {
+    try {
+        const serialized = JSON.stringify(value, (_key, nested) => {
+            if (nested instanceof Error) {
+                return {
+                    name: nested.name,
+                    message: nested.message,
+                };
+            }
+            return nested;
+        });
+        return serialized ?? "null";
+    }
+    catch (err) {
+        return JSON.stringify({
+            type: "deepccc_raw_stream_log_serialize_error",
+            message: errorMessage(err),
+        });
+    }
+}
+function truncateToolContext(value) {
+    return value.length > 8000 ? `${value.slice(0, 8000)}...[truncated]` : value;
+}
+function formatDuration(ms) {
+    if (ms % 60_000 === 0)
+        return `${ms / 60_000} minutes`;
+    if (ms % 1_000 === 0)
+        return `${ms / 1_000} seconds`;
+    return `${ms} ms`;
+}
+function errorMessage(value) {
+    return value instanceof Error ? value.message : String(value);
+}