@deadragdoll/tellymcp 0.0.6 → 0.0.8

package/dist/services/features/telegram-mcp/src/shared/integrations/telegram/transport.js

@@ -19,6 +19,7 @@ const proxyFetch_1 = require("./proxyFetch");
 const client_1 = require("../tmux/client");
 const versionHandshake_1 = require("../../lib/version/versionHandshake");
 const LOCAL_INDEX_FILE_NAME = "LOCAL_INDEX.md";
+const TMUX_NUDGE_FAILURE_NOTICE_COOLDOWN_MS = 5 * 60 * 1000;
 function trimTrailingSlashes(value) {
     return value.replace(/\/+$/u, "");
 }
@@ -306,6 +307,7 @@ class TelegramTransport {
     screenshotMessageMenu;
     waiters = new Map();
     tmuxNudgeDebounceTimers = new Map();
+    tmuxNudgeFailureNoticeAt = new Map();
     pendingRenames = new Map();
     pendingBroadcasts = new Map();
     pendingPartnerNotes = new Map();
@@ -2585,22 +2587,117 @@ class TelegramTransport {
             return;
         }
         await this.sendTypingForSession(sessionId);
-        await (0, client_1.sendTmuxLiteralLine)(this.config.tmux, session.tmuxTarget, input.message);
+        let tmuxTarget = session.tmuxTarget;
+        try {
+            await (0, client_1.sendTmuxLiteralLine)(this.config.tmux, tmuxTarget, input.message);
+        }
+        catch (error) {
+            if ((0, client_1.isTmuxTargetInvalidError)(error)) {
+                const recoveredTarget = await this.tryRecoverTmuxTarget(sessionId, session);
+                if (recoveredTarget) {
+                    tmuxTarget = recoveredTarget;
+                    await (0, client_1.sendTmuxLiteralLine)(this.config.tmux, recoveredTarget, input.message);
+                }
+                else {
+                    await this.notifyTmuxTargetInvalid(sessionId, session, error);
+                    throw error;
+                }
+            }
+            else {
+                throw error;
+            }
+        }
         const lastTmuxNudgeAt = new Date(nowMs).toISOString();
         await this.sessionStore.setSession({
             ...session,
+            tmuxTarget,
+            ...(tmuxTarget ? { tmuxPaneId: tmuxTarget } : {}),
             lastTmuxNudgeAt,
         });
+        this.tmuxNudgeFailureNoticeAt.delete(sessionId);
         this.logger.info("tmux nudge sent", {
             sessionId,
             reason: input.reason,
             message: input.message,
             tmuxSessionName: session.tmuxSessionName,
-            tmuxTarget: session.tmuxTarget,
+            tmuxTarget,
             inboxCount,
             lastTmuxNudgeAt,
         });
     }
+    async tryRecoverTmuxTarget(sessionId, session) {
+        const recoveredTarget = await (0, client_1.resolveTmuxTargetFromHint)(this.config.tmux, {
+            tmuxSessionName: session.tmuxSessionName,
+            tmuxWindowName: session.tmuxWindowName,
+            tmuxWindowIndex: session.tmuxWindowIndex,
+            tmuxPaneId: session.tmuxPaneId,
+            tmuxPaneIndex: session.tmuxPaneIndex,
+            tmuxTarget: session.tmuxTarget,
+        });
+        if (!recoveredTarget || recoveredTarget === session.tmuxTarget) {
+            return recoveredTarget;
+        }
+        await this.sessionStore.setSession({
+            ...session,
+            tmuxTarget: recoveredTarget,
+            tmuxPaneId: recoveredTarget,
+            updatedAt: new Date().toISOString(),
+        });
+        this.logger.warn("tmux target auto-recovered", {
+            sessionId,
+            previousTmuxTarget: session.tmuxTarget,
+            recoveredTmuxTarget: recoveredTarget,
+            tmuxSessionName: session.tmuxSessionName,
+            tmuxWindowName: session.tmuxWindowName,
+            tmuxWindowIndex: session.tmuxWindowIndex,
+            tmuxPaneIndex: session.tmuxPaneIndex,
+        });
+        return recoveredTarget;
+    }
+    async notifyTmuxTargetInvalid(sessionId, session, error) {
+        const binding = await this.bindingStore.getBinding(sessionId);
+        if (!binding) {
+            return;
+        }
+        const nowMs = Date.now();
+        const lastNoticeAt = this.tmuxNudgeFailureNoticeAt.get(sessionId);
+        if (lastNoticeAt &&
+            nowMs - lastNoticeAt < TMUX_NUDGE_FAILURE_NOTICE_COOLDOWN_MS) {
+            return;
+        }
+        this.tmuxNudgeFailureNoticeAt.set(sessionId, nowMs);
+        const sessionLabel = session.label ?? sessionId;
+        const tmuxTarget = session.tmuxTarget ?? "unknown";
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        try {
+            await this.sendNotification({
+                sessionId,
+                sessionLabel: "TellyMCP",
+                recipient: {
+                    telegramChatId: binding.telegramChatId,
+                    telegramUserId: binding.telegramUserId,
+                },
+                message: [
+                    `⚠️ Автоматический tmux nudge для сессии ${sessionLabel} не сработал.`,
+                    `Сохранённый tmux target больше недействителен: ${tmuxTarget}`,
+                    `Ошибка: ${errorMessage}`,
+                    "Обычно это значит, что pane/window/session был пересоздан.",
+                    "Перепривяжи tmux target для этой сессии.",
+                ].join("\n"),
+            });
+        }
+        catch (notifyError) {
+            this.logger.warn("Failed to deliver tmux target failure notification", {
+                sessionId,
+                tmuxTarget,
+                telegramChatId: binding.telegramChatId,
+                telegramUserId: binding.telegramUserId,
+                notifyError: notifyError instanceof Error
+                    ? (notifyError.stack ?? notifyError.message)
+                    : String(notifyError),
+            });
+        }
+    }
     async sendTypingForSession(sessionId) {
         const binding = await this.bindingStore.getBinding(sessionId);
         if (!binding) {
@@ -6454,7 +6551,7 @@ class TelegramTransport {
             telegramUserId: input.principal.telegramUserId,
             sourceTelegramMessageId: input.sourceTelegramMessageId,
             text: [
-                "Пользователь просит текущую сессию подготовить сообщение для другой сессии.",
+                "Пользователь просит текущую сессию выполнить работу и отправить результат другой сессии.",
                 `Маршрут отправки: ${sourceLabel} -> ${targetLabel}`,
                 `Тип: ${input.kind}`,
                 `Кратко: ${input.summary}`,
@@ -6466,6 +6563,9 @@ class TelegramTransport {
                 "Содержимое для отправки:",
                 input.message,
                 "",
+                "Не пересылай это как новую задачу в target-сессию.",
+                "Сначала выполни работу в текущей сессии сам.",
+                "Через send_partner_note или send_partner_file отправляй только результат, а не исходное поручение.",
                 "Не используй linked partner для отправки. Передай target_session_id явно в send_partner_note.",
                 "После подготовки обязательно используй send_partner_note.",
                 "Задача не завершена, пока send_partner_note не отработал успешно.",

package/dist/services/features/telegram-mcp/src/shared/integrations/tmux/client.js

@@ -10,6 +10,8 @@ exports.listXchangeFiles = listXchangeFiles;
 exports.deleteXchangeFile = deleteXchangeFile;
 exports.readWorkspaceFile = readWorkspaceFile;
 exports.isTmuxUnavailableError = isTmuxUnavailableError;
+exports.isTmuxTargetInvalidError = isTmuxTargetInvalidError;
+exports.resolveTmuxTargetFromHint = resolveTmuxTargetFromHint;
 exports.getTmuxWindowHeight = getTmuxWindowHeight;
 exports.captureTmuxPaneRange = captureTmuxPaneRange;
 exports.captureVisibleTmuxPane = captureVisibleTmuxPane;
@@ -189,6 +191,79 @@ function isTmuxUnavailableError(error) {
         message.includes("ENOENT") ||
         message.includes("tmux is unavailable"));
 }
+function isTmuxTargetInvalidError(error) {
+    const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+    return (message.includes("can't find pane") ||
+        message.includes("can't find window") ||
+        message.includes("can't find session"));
+}
+async function listTmuxPanes(config) {
+    const { stdout } = await execFileOutputAsync("tmux", buildTmuxArgs(config, [
+        "list-panes",
+        "-a",
+        "-F",
+        "#{session_name}\t#{window_name}\t#{window_index}\t#{pane_id}\t#{pane_index}",
+    ]));
+    return stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .map((line) => {
+        const [sessionName = "", windowName = "", windowIndexRaw = "", paneId = "", paneIndexRaw = ""] = line.split("\t");
+        return {
+            sessionName,
+            windowName,
+            windowIndex: Number.parseInt(windowIndexRaw, 10),
+            paneId,
+            paneIndex: Number.parseInt(paneIndexRaw, 10),
+        };
+    })
+        .filter((pane) => pane.sessionName &&
+        pane.paneId &&
+        Number.isFinite(pane.windowIndex) &&
+        Number.isFinite(pane.paneIndex));
+}
+async function resolveTmuxTargetFromHint(config, hint) {
+    const panes = await listTmuxPanes(config);
+    const byPaneId = hint.tmuxPaneId
+        ? panes.find((pane) => pane.paneId === hint.tmuxPaneId)
+        : null;
+    if (byPaneId) {
+        return byPaneId.paneId;
+    }
+    const exactMatch = panes.find((pane) => {
+        if (!hint.tmuxSessionName) {
+            return false;
+        }
+        if (pane.sessionName !== hint.tmuxSessionName) {
+            return false;
+        }
+        if (typeof hint.tmuxWindowIndex === "number" &&
+            pane.windowIndex !== hint.tmuxWindowIndex) {
+            return false;
+        }
+        if (typeof hint.tmuxPaneIndex === "number" &&
+            pane.paneIndex !== hint.tmuxPaneIndex) {
+            return false;
+        }
+        if (hint.tmuxWindowName &&
+            pane.windowName !== hint.tmuxWindowName) {
+            return false;
+        }
+        return true;
+    });
+    if (exactMatch) {
+        return exactMatch.paneId;
+    }
+    const fallbackBySessionAndPane = panes.find((pane) => {
+        if (!hint.tmuxSessionName || typeof hint.tmuxPaneIndex !== "number") {
+            return false;
+        }
+        return (pane.sessionName === hint.tmuxSessionName &&
+            pane.paneIndex === hint.tmuxPaneIndex);
+    });
+    return fallbackBySessionAndPane?.paneId ?? null;
+}
 async function getTmuxWindowHeight(config, target) {
     const { stdout: heightRaw } = await execFileOutputAsync("tmux", buildTmuxArgs(config, ["display-message", "-p", "-t", target, "#{window_height}"]));
     const height = Number.parseInt(heightRaw.trim(), 10);

package/dist/services/features/telegram-mcp/src/shared/lib/logger/logger.js

@@ -4,10 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLogger = createLogger;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
 const pino_1 = __importDefault(require("pino"));
-const DEFAULT_LOG_FILE_PATH = ".telegram-human-mcp/log.jsonl";
+const pinoTargets_1 = require("../../../../../../../lib/pinoTargets");
 function write(logger, level, message, meta) {
     if (meta) {
         logger[level](meta, message);
@@ -16,32 +14,15 @@ function write(logger, level, message, meta) {
     logger[level](message);
 }
 function createLogger(config) {
-    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(DEFAULT_LOG_FILE_PATH), { recursive: true });
     const transport = pino_1.default.transport({
-        targets: [
-            {
-                target: "pino/file",
-                level: config.logging.level,
-                options: {
-                    destination: DEFAULT_LOG_FILE_PATH,
-                    mkdir: true,
-                },
-            },
-            {
-                target: "pino-pretty",
-                level: config.logging.level,
-                options: {
-                    destination: 2,
-                    colorize: true,
-                    translateTime: "SYS:standard",
-                    ignore: "pid,hostname",
-                    singleLine: false,
-                },
-            },
-        ],
+        targets: (0, pinoTargets_1.createPinoTargets)({
+            level: config.logging.level,
+            fileEnabled: config.logging.fileEnabled,
+            filePath: config.logging.filePath,
+        }),
     });
     const baseLogger = (0, pino_1.default)({
-        name: "telegram-human-mcp",
+        name: "tellymcp",
         level: config.logging.level,
         timestamp: pino_1.default.stdTimeFunctions.isoTime,
     }, transport);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deadragdoll/tellymcp",
-  "version": "0.0.6",
-  "description": "TellyMCP - Telegram Human-in-the-Loop MCP Server",
+  "version": "0.0.8",
+  "description": "TellyMCP - Telegram control plane for MCP-connected coding agents",
   "main": "dist/services/features/telegram-mcp/runtime.service.js",
   "bin": {
     "tellymcp": "dist/cli.js"
@@ -75,7 +75,6 @@
     "amqplib": "0.10.9",
     "dotenv": "^17.4.2",
     "grammy": "1.43.0",
-    "graphql": "^16.14.0",
     "https-proxy-agent": "^7.0.6",
     "ioredis": "5.10.1",
     "knex": "^3.2.10",
@@ -88,7 +87,6 @@
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
     "playwright": "^1.60.0",
-    "redis": "5.12.1",
     "socks-proxy-agent": "^8.0.5",
     "ws": "8.20.1",
     "zod": "4.4.3"

package/dist/lib/middlewares/tracer.js

@@ -1,172 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTracerMiddleware = void 0;
-const traceContext_1 = require("../traceContext");
-const trace_1 = require("../trace");
-const shouldSkipTrace = (actionName, ctx) => Boolean(ctx?.meta?.$traceInternal ||
-    !actionName ||
-    actionName === "context" ||
-    actionName === "graphql.publish" ||
-    (actionName === "rest" && ctx?.params?.req?.url === "/api/graphql"));
-const createTracerMiddleware = () => {
-    let broker = null;
-    const resolveTracer = (action) => {
-        const rawName = String(action?.rawName || action?.name || "");
-        if (action?.tracer)
-            return { tracer: action.tracer, source: "action.tracer" };
-        if (action?.schema?.tracer)
-            return { tracer: action.schema.tracer, source: "action.schema.tracer" };
-        if (action?.service?.schema?.actions?.[rawName]?.tracer) {
-            return {
-                tracer: action.service.schema.actions[rawName].tracer,
-                source: "service.schema.actions[rawName].tracer",
-            };
-        }
-        return {};
-    };
-    const callTrace = async (ctx, actionName, params, silent = false) => {
-        if (!broker) {
-            return null;
-        }
-        try {
-            return await broker.call(actionName, params, {
-                requestID: ctx.requestID,
-                meta: {
-                    user: ctx.meta?.user,
-                    $traceInternal: true,
-                },
-            });
-        }
-        catch (error) {
-            if (!silent) {
-                broker.logger.warn("Tracer call failed", {
-                    actionName,
-                    sourceAction: ctx.action?.name || null,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-            return null;
-        }
-    };
-    return {
-        created(localBroker) {
-            broker = localBroker;
-        },
-        localAction(next, action) {
-            const actionName = String(action?.rawName || action?.name || "");
-            const serviceName = String(action?.service?.name || "");
-            return async function traceAction(ctx) {
-                if (serviceName === "trace" || shouldSkipTrace(actionName, ctx)) {
-                    return next(ctx);
-                }
-                const resolvedTracer = resolveTracer(ctx?.action || action);
-                const tracer = resolvedTracer.tracer;
-                let traceMeta = null;
-                const startSessionName = tracer?.startSession;
-                const tracerTag = tracer?.tag;
-                const shouldStartRootSession = Boolean(startSessionName);
-                if (!shouldStartRootSession) {
-                    traceMeta = await (0, traceContext_1.loadTraceContext)();
-                }
-                let startedSession = false;
-                if (shouldStartRootSession) {
-                    await (0, traceContext_1.deleteTraceContext)().catch(() => null);
-                    const session = (await callTrace(ctx, "trace.startSession", {
-                        name: startSessionName,
-                        tag: tracerTag || null,
-                        source: actionName,
-                        meta: (0, trace_1.sanitizeTraceValue)({
-                            action: actionName,
-                            params: ctx.params,
-                        }),
-                    }, false));
-                    if (session?.session_id) {
-                        traceMeta = {
-                            sessionId: String(session.session_id),
-                            name: startSessionName ?? null,
-                            tag: tracerTag || null,
-                            rootAction: actionName,
-                            startedBy: actionName,
-                        };
-                        await (0, traceContext_1.saveTraceContext)(traceMeta);
-                        startedSession = true;
-                    }
-                }
-                const sessionId = String(traceMeta?.sessionId || "").trim();
-                const hasSession = Boolean(sessionId);
-                const startedAt = Date.now();
-                if (hasSession) {
-                    await (0, traceContext_1.touchTraceContext)().catch(() => null);
-                    await callTrace(ctx, "trace.log", {
-                        session_id: sessionId,
-                        level: (0, trace_1.normalizeTraceLevel)(tracer?.level || "debug"),
-                        action: actionName,
-                        state: "started",
-                        marker: tracer?.marker || null,
-                        step: tracer?.step || "action",
-                        message: actionName,
-                        data: (0, trace_1.buildTraceStartData)(ctx, actionName, tracer, startedSession),
-                    }, false);
-                }
-                try {
-                    const result = await next(ctx);
-                    const durationMs = Date.now() - startedAt;
-                    if (hasSession) {
-                        await callTrace(ctx, "trace.log", {
-                            session_id: sessionId,
-                            level: (0, trace_1.normalizeTraceLevel)(tracer?.level || "debug"),
-                            action: actionName,
-                            state: "succeeded",
-                            marker: tracer?.marker || null,
-                            step: tracer?.step || "action",
-                            message: actionName,
-                            data: (0, trace_1.buildTraceSuccessData)(ctx, actionName, result, durationMs, tracer),
-                        }, false);
-                        if (tracer?.stopSession) {
-                            await callTrace(ctx, "trace.endSession", {
-                                session_id: sessionId,
-                                status: "succeeded",
-                                summary: `${actionName} completed`,
-                                meta: (0, trace_1.sanitizeTraceValue)({
-                                    action: actionName,
-                                    durationMs,
-                                }),
-                            }, false);
-                            await (0, traceContext_1.deleteTraceContext)();
-                        }
-                    }
-                    return result;
-                }
-                catch (error) {
-                    const durationMs = Date.now() - startedAt;
-                    if (hasSession) {
-                        await callTrace(ctx, "trace.log", {
-                            session_id: sessionId,
-                            level: "error",
-                            action: actionName,
-                            state: "failed",
-                            marker: tracer?.marker || null,
-                            step: tracer?.step || "action",
-                            message: actionName,
-                            data: (0, trace_1.buildTraceErrorData)(ctx, actionName, error, durationMs, tracer),
-                        }, false);
-                        if (tracer?.stopSession || startedSession) {
-                            await callTrace(ctx, "trace.endSession", {
-                                session_id: sessionId,
-                                status: "failed",
-                                summary: error instanceof Error ? error.message : `Action failed: ${actionName}`,
-                                meta: (0, trace_1.sanitizeTraceValue)({
-                                    action: actionName,
-                                    durationMs,
-                                }),
-                            }, false);
-                            await (0, traceContext_1.deleteTraceContext)();
-                        }
-                    }
-                    throw error;
-                }
-            };
-        },
-    };
-};
-exports.createTracerMiddleware = createTracerMiddleware;

package/dist/lib/trace.js

@@ -1,147 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildTraceErrorData = exports.buildTraceSuccessData = exports.buildTraceStartData = exports.buildTraceMetaSummary = exports.sanitizeTraceValue = exports.normalizeTraceLevel = void 0;
-const TRACE_MAX_DEPTH = 4;
-const TRACE_MAX_ARRAY = 25;
-const TRACE_MAX_KEYS = 40;
-const TRACE_MAX_STRING = 1000;
-const truncateString = (value) => value.length > TRACE_MAX_STRING ? `${value.slice(0, TRACE_MAX_STRING)}...` : value;
-const normalizeTraceLevel = (value) => {
-    const level = String(value || "info").toLowerCase();
-    if (["fatal", "error", "warn", "info", "debug", "trace"].includes(level)) {
-        return level;
-    }
-    return "info";
-};
-exports.normalizeTraceLevel = normalizeTraceLevel;
-const sanitizeError = (error, depth, seen) => {
-    if (!(error instanceof Error)) {
-        return (0, exports.sanitizeTraceValue)(error, depth, seen);
-    }
-    return {
-        name: error.name,
-        message: truncateString(error.message || ""),
-        stack: truncateString(error.stack || ""),
-    };
-};
-const sanitizeTraceValue = (value, depth = 0, seen = new WeakSet()) => {
-    if (value == null || typeof value === "boolean" || typeof value === "number") {
-        return value;
-    }
-    if (typeof value === "string") {
-        return truncateString(value);
-    }
-    if (typeof value === "bigint") {
-        return value.toString();
-    }
-    if (typeof value === "symbol") {
-        return value.toString();
-    }
-    if (typeof value === "function") {
-        return `[Function ${value.name || "anonymous"}]`;
-    }
-    if (value instanceof Date) {
-        return value.toISOString();
-    }
-    if (value instanceof Error) {
-        return sanitizeError(value, depth, seen);
-    }
-    if (Buffer.isBuffer(value)) {
-        return `[Buffer ${value.length}]`;
-    }
-    if (value instanceof Set) {
-        return {
-            type: "Set",
-            size: value.size,
-            values: Array.from(value.values())
-                .slice(0, TRACE_MAX_ARRAY)
-                .map(item => (0, exports.sanitizeTraceValue)(item, depth + 1, seen)),
-        };
-    }
-    if (value instanceof Map) {
-        return {
-            type: "Map",
-            size: value.size,
-            entries: Array.from(value.entries())
-                .slice(0, TRACE_MAX_ARRAY)
-                .map(([key, item]) => [
-                (0, exports.sanitizeTraceValue)(key, depth + 1, seen),
-                (0, exports.sanitizeTraceValue)(item, depth + 1, seen),
-            ]),
-        };
-    }
-    if (Array.isArray(value)) {
-        if (depth >= TRACE_MAX_DEPTH) {
-            return `[Array(${value.length})]`;
-        }
-        return value
-            .slice(0, TRACE_MAX_ARRAY)
-            .map(item => (0, exports.sanitizeTraceValue)(item, depth + 1, seen));
-    }
-    if (typeof value === "object") {
-        const objectValue = value;
-        if (seen.has(objectValue)) {
-            return "[Circular]";
-        }
-        seen.add(objectValue);
-        if (depth >= TRACE_MAX_DEPTH) {
-            return `[${objectValue?.constructor?.name || "Object"}]`;
-        }
-        const keys = Object.keys(objectValue).slice(0, TRACE_MAX_KEYS);
-        const result = {};
-        for (const key of keys) {
-            result[key] = (0, exports.sanitizeTraceValue)(objectValue[key], depth + 1, seen);
-        }
-        if (Object.keys(objectValue).length > TRACE_MAX_KEYS) {
-            result.__truncatedKeys = Object.keys(objectValue).length - TRACE_MAX_KEYS;
-        }
-        return result;
-    }
-    return String(value);
-};
-exports.sanitizeTraceValue = sanitizeTraceValue;
-const pickFields = (source, fields) => {
-    if (fields === false) {
-        return undefined;
-    }
-    if (fields === true || fields == null) {
-        return (0, exports.sanitizeTraceValue)(source);
-    }
-    if (!source || typeof source !== "object") {
-        return (0, exports.sanitizeTraceValue)(source);
-    }
-    const result = {};
-    for (const key of fields) {
-        result[key] = (0, exports.sanitizeTraceValue)(source[key]);
-    }
-    return result;
-};
-const buildTraceMetaSummary = (ctx) => (0, exports.sanitizeTraceValue)({
-    requestID: ctx.requestID || null,
-    userSub: ctx.meta?.user?.sub || null,
-});
-exports.buildTraceMetaSummary = buildTraceMetaSummary;
-const buildTraceStartData = (ctx, actionName, tracer, startedSession = false) => (0, exports.sanitizeTraceValue)({
-    action: actionName,
-    startedSession,
-    params: pickFields(ctx.params, tracer?.captureParams),
-    meta: (0, exports.buildTraceMetaSummary)(ctx),
-});
-exports.buildTraceStartData = buildTraceStartData;
-const buildTraceSuccessData = (ctx, actionName, result, durationMs, tracer) => (0, exports.sanitizeTraceValue)({
-    action: actionName,
-    durationMs,
-    result: tracer?.captureResult === undefined
-        ? undefined
-        : pickFields(result, tracer.captureResult),
-});
-exports.buildTraceSuccessData = buildTraceSuccessData;
-const buildTraceErrorData = (ctx, actionName, error, durationMs, tracer) => (0, exports.sanitizeTraceValue)({
-    action: actionName,
-    durationMs,
-    error: tracer?.captureError === undefined
-        ? sanitizeError(error, 0, new WeakSet())
-        : pickFields(error, tracer.captureError),
-    meta: (0, exports.buildTraceMetaSummary)(ctx),
-});
-exports.buildTraceErrorData = buildTraceErrorData;