taurusdb-mcp 0.1.0

package/dist/tools/taurus/diagnostics.js

@@ -0,0 +1,323 @@
+import { z } from "zod";
+import { formatSuccess, } from "../../utils/formatter.js";
+import { formatToolError, ToolInputError } from "../error-handling.js";
+import { asOptionalBoolean, asOptionalPositiveInteger, asOptionalString, diagnosticBaseInputShape, metadata, toPublicDbHotspotResult, resolveContext, toPublicDiagnosticResult, toPublicServiceLatencyResult, toPublicTopSlowSqlResult, } from "../common.js";
+function parseBaseInput(input) {
+    return {
+        datasource: asOptionalString(input.datasource, "datasource"),
+        database: asOptionalString(input.database, "database"),
+        timeRange: parseTimeRange(input.time_range),
+        evidenceLevel: parseEvidenceLevel(input.evidence_level),
+        includeRawEvidence: asOptionalBoolean(input.include_raw_evidence, "include_raw_evidence"),
+        maxCandidates: asOptionalPositiveInteger(input.max_candidates, "max_candidates"),
+    };
+}
+function parseTimeRange(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new ToolInputError("Invalid time_range: expected an object.");
+    }
+    const raw = value;
+    return {
+        from: asOptionalString(raw.from, "time_range.from"),
+        to: asOptionalString(raw.to, "time_range.to"),
+        relative: asOptionalString(raw.relative, "time_range.relative"),
+    };
+}
+function parseEvidenceLevel(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "basic" || value === "standard" || value === "full") {
+        return value;
+    }
+    throw new ToolInputError("Invalid evidence_level: expected basic, standard, or full.");
+}
+function parseStorageScope(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "instance" || value === "database" || value === "table") {
+        return value;
+    }
+    throw new ToolInputError("Invalid scope: expected instance, database, or table.");
+}
+function parseDbHotspotScope(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "sql" || value === "table" || value === "session") {
+        return value;
+    }
+    throw new ToolInputError("Invalid scope: expected sql, table, or session.");
+}
+function parseLatencySymptom(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "latency"
+        || value === "timeout"
+        || value === "cpu"
+        || value === "connection_growth") {
+        return value;
+    }
+    throw new ToolInputError("Invalid symptom: expected latency, timeout, cpu, or connection_growth.");
+}
+function parseTopSlowSqlSortBy(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "avg_latency"
+        || value === "total_latency"
+        || value === "exec_count"
+        || value === "lock_time") {
+        return value;
+    }
+    throw new ToolInputError("Invalid sort_by: expected avg_latency, total_latency, exec_count, or lock_time.");
+}
+function summarizeDiagnostic(toolLabel, status) {
+    return `${toolLabel} returned ${status}.`;
+}
+export const findTopSlowSqlTool = {
+    name: "find_top_slow_sql",
+    description: "Find the most suspicious slow SQL statements for the selected datasource, database, and time window.",
+    inputSchema: {
+        ...diagnosticBaseInputShape,
+        top_n: z.number().int().positive().max(20).optional().describe("Maximum number of suspect SQL statements to return."),
+        sort_by: z
+            .enum(["avg_latency", "total_latency", "exec_count", "lock_time"])
+            .optional()
+            .describe("Ranking strategy for slow SQL discovery."),
+    },
+    async handler(input, deps, context) {
+        try {
+            const ctx = await resolveContext(input, deps, context, true);
+            const result = await deps.engine.findTopSlowSql({
+                ...parseBaseInput(input),
+                topN: asOptionalPositiveInteger(input.top_n, "top_n"),
+                sortBy: parseTopSlowSqlSortBy(input.sort_by),
+            }, ctx);
+            return formatSuccess(toPublicTopSlowSqlResult(result), {
+                summary: summarizeDiagnostic("Top slow SQL discovery", result.status),
+                metadata: metadata(context.taskId),
+            });
+        }
+        catch (error) {
+            return formatToolError(error, {
+                action: "find_top_slow_sql",
+                metadata: metadata(context.taskId),
+            });
+        }
+    },
+};
+export const diagnoseServiceLatencyTool = {
+    name: "diagnose_service_latency",
+    description: "Route a business-latency symptom to the most likely SQL, lock, or connection suspects and suggest the next diagnostic tool.",
+    inputSchema: {
+        ...diagnosticBaseInputShape,
+        user: diagnosticString("Optional user to focus on."),
+        client_host: diagnosticString("Optional client host or IP to focus on."),
+        symptom: z
+            .enum(["latency", "timeout", "cpu", "connection_growth"])
+            .optional()
+            .describe("Primary service symptom to route: latency, timeout, cpu, or connection_growth."),
+    },
+    async handler(input, deps, context) {
+        try {
+            const ctx = await resolveContext(input, deps, context, true);
+            const result = await deps.engine.diagnoseServiceLatency({
+                ...parseBaseInput(input),
+                user: asOptionalString(input.user, "user"),
+                clientHost: asOptionalString(input.client_host, "client_host"),
+                symptom: parseLatencySymptom(input.symptom),
+            }, ctx);
+            return formatSuccess(toPublicServiceLatencyResult(result), {
+                summary: summarizeDiagnostic("Service-latency diagnosis", result.status),
+                metadata: metadata(context.taskId),
+            });
+        }
+        catch (error) {
+            return formatToolError(error, {
+                action: "diagnose_service_latency",
+                metadata: metadata(context.taskId),
+            });
+        }
+    },
+};
+export const diagnoseDbHotspotTool = {
+    name: "diagnose_db_hotspot",
+    description: "Identify the hottest SQL, table, or session currently dragging down the datasource and recommend the next diagnostic tool.",
+    inputSchema: {
+        ...diagnosticBaseInputShape,
+        scope: z
+            .enum(["sql", "table", "session"])
+            .optional()
+            .describe("Optional hotspot scope: sql, table, or session."),
+    },
+    async handler(input, deps, context) {
+        try {
+            const ctx = await resolveContext(input, deps, context, true);
+            const result = await deps.engine.diagnoseDbHotspot({
+                ...parseBaseInput(input),
+                scope: parseDbHotspotScope(input.scope),
+            }, ctx);
+            return formatSuccess(toPublicDbHotspotResult(result), {
+                summary: summarizeDiagnostic("Database-hotspot diagnosis", result.status),
+                metadata: metadata(context.taskId),
+            });
+        }
+        catch (error) {
+            return formatToolError(error, {
+                action: "diagnose_db_hotspot",
+                metadata: metadata(context.taskId),
+            });
+        }
+    },
+};
+export const diagnoseSlowQueryTool = {
+    name: "diagnose_slow_query",
+    description: "Diagnose why a SQL statement is slow using live EXPLAIN evidence and, when digest history is available, performance_schema runtime wait evidence.",
+    inputSchema: {
+        ...diagnosticBaseInputShape,
+        sql: diagnosticString("SQL text to diagnose."),
+        sql_hash: diagnosticString("Normalized SQL hash to diagnose."),
+        digest_text: diagnosticString("SQL digest text to diagnose."),
+    },
+    async handler(input, deps, context) {
+        try {
+            const ctx = await resolveContext(input, deps, context, true);
+            const diagnosticInput = {
+                ...parseBaseInput(input),
+                sql: asOptionalString(input.sql, "sql"),
+                sqlHash: asOptionalString(input.sql_hash, "sql_hash"),
+                digestText: asOptionalString(input.digest_text, "digest_text"),
+            };
+            if (!diagnosticInput.sql && !diagnosticInput.sqlHash && !diagnosticInput.digestText) {
+                throw new ToolInputError("diagnose_slow_query requires sql, sql_hash, or digest_text.");
+            }
+            const result = await deps.engine.diagnoseSlowQuery(diagnosticInput, ctx);
+            return formatSuccess(toPublicDiagnosticResult(result), {
+                summary: summarizeDiagnostic("Slow-query diagnosis", result.status),
+                metadata: metadata(context.taskId),
+            });
+        }
+        catch (error) {
+            return formatToolError(error, {
+                action: "diagnose_slow_query",
+                metadata: metadata(context.taskId),
+            });
+        }
+    },
+};
+export const diagnoseConnectionSpikeTool = {
+    name: "diagnose_connection_spike",
+    description: "Diagnose connection spikes using live processlist evidence plus structured heuristic analysis.",
+    inputSchema: {
+        ...diagnosticBaseInputShape,
+        user: diagnosticString("Optional user to focus on."),
+        client_host: diagnosticString("Optional client host or IP to focus on."),
+        compare_baseline: diagnosticBoolean("Whether to compare the selected window with a baseline."),
+    },
+    async handler(input, deps, context) {
+        try {
+            const ctx = await resolveContext(input, deps, context, true);
+            const diagnosticInput = {
+                ...parseBaseInput(input),
+                user: asOptionalString(input.user, "user"),
+                clientHost: asOptionalString(input.client_host, "client_host"),
+                compareBaseline: asOptionalBoolean(input.compare_baseline, "compare_baseline"),
+            };
+            const result = await deps.engine.diagnoseConnectionSpike(diagnosticInput, ctx);
+            return formatSuccess(toPublicDiagnosticResult(result), {
+                summary: summarizeDiagnostic("Connection-spike diagnosis", result.status),
+                metadata: metadata(context.taskId),
+            });
+        }
+        catch (error) {
+            return formatToolError(error, {
+                action: "diagnose_connection_spike",
+                metadata: metadata(context.taskId),
+            });
+        }
+    },
+};
+export const diagnoseLockContentionTool = {
+    name: "diagnose_lock_contention",
+    description: "Diagnose InnoDB lock contention using live lock-wait evidence plus structured heuristic analysis.",
+    inputSchema: {
+        ...diagnosticBaseInputShape,
+        table: diagnosticString("Optional table to focus on."),
+        blocker_session_id: diagnosticString("Optional blocker session identifier to focus on."),
+    },
+    async handler(input, deps, context) {
+        try {
+            const ctx = await resolveContext(input, deps, context, true);
+            const diagnosticInput = {
+                ...parseBaseInput(input),
+                table: asOptionalString(input.table, "table"),
+                blockerSessionId: asOptionalString(input.blocker_session_id, "blocker_session_id"),
+            };
+            const result = await deps.engine.diagnoseLockContention(diagnosticInput, ctx);
+            return formatSuccess(toPublicDiagnosticResult(result), {
+                summary: summarizeDiagnostic("Lock-contention diagnosis", result.status),
+                metadata: metadata(context.taskId),
+            });
+        }
+        catch (error) {
+            return formatToolError(error, {
+                action: "diagnose_lock_contention",
+                metadata: metadata(context.taskId),
+            });
+        }
+    },
+};
+export const diagnoseStoragePressureTool = {
+    name: "diagnose_storage_pressure",
+    description: "Diagnose local storage-pressure signals using statement digest counters and table storage metadata.",
+    inputSchema: {
+        ...diagnosticBaseInputShape,
+        scope: diagnosticEnum("Diagnosis scope: instance, database, or table."),
+        table: diagnosticString("Optional table to focus on when scope is table."),
+    },
+    async handler(input, deps, context) {
+        try {
+            const ctx = await resolveContext(input, deps, context, true);
+            const diagnosticInput = {
+                ...parseBaseInput(input),
+                scope: parseStorageScope(input.scope),
+                table: asOptionalString(input.table, "table"),
+            };
+            const result = await deps.engine.diagnoseStoragePressure(diagnosticInput, ctx);
+            return formatSuccess(toPublicDiagnosticResult(result), {
+                summary: summarizeDiagnostic("Storage-pressure diagnosis", result.status),
+                metadata: metadata(context.taskId),
+            });
+        }
+        catch (error) {
+            return formatToolError(error, {
+                action: "diagnose_storage_pressure",
+                metadata: metadata(context.taskId),
+            });
+        }
+    },
+};
+export const diagnosticToolDefinitions = [
+    diagnoseServiceLatencyTool,
+    diagnoseDbHotspotTool,
+    findTopSlowSqlTool,
+    diagnoseSlowQueryTool,
+    diagnoseConnectionSpikeTool,
+    diagnoseLockContentionTool,
+    diagnoseStoragePressureTool,
+];
+function diagnosticString(description) {
+    return z.string().trim().min(1).optional().describe(description);
+}
+function diagnosticBoolean(description) {
+    return z.boolean().optional().describe(description);
+}
+function diagnosticEnum(description) {
+    return z.enum(["instance", "database", "table"]).optional().describe(description);
+}

package/dist/tools/taurus/explain.d.ts

@@ -0,0 +1,2 @@
+import type { ToolDefinition } from "../registry.js";
+export declare const explainSqlEnhancedTool: ToolDefinition;

package/dist/tools/taurus/explain.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { formatBlocked, formatSuccess } from "../../utils/formatter.js";
+import { formatToolError } from "../error-handling.js";
+import { asRequiredString, contextInputShape, metadata, resolveContext, statementTypeFromSql, toPublicEnhancedExplainResult, } from "../common.js";
+const READONLY_EXPLAIN_TYPES = new Set(["select", "show", "describe", "explain"]);
+function isReadonlyExplainSql(sql) {
+    const statementType = statementTypeFromSql(sql);
+    return statementType !== undefined && READONLY_EXPLAIN_TYPES.has(statementType);
+}
+export const explainSqlEnhancedTool = {
+    name: "explain_sql_enhanced",
+    description: "Run TaurusDB-aware EXPLAIN on a readonly SQL statement and return NDP/PQ/OFFSET hints with optimization suggestions.",
+    inputSchema: {
+        ...contextInputShape,
+        sql: z.string().trim().min(1).describe("Readonly SQL statement to analyze."),
+    },
+    async handler(input, deps, context) {
+        const sql = asRequiredString(input.sql, "sql");
+        const statementType = statementTypeFromSql(sql);
+        try {
+            if (!isReadonlyExplainSql(sql)) {
+                return formatBlocked({
+                    reason: "Tool explain_sql_enhanced only supports readonly SQL statements.",
+                    metadata: metadata(context.taskId, {
+                        statement_type: statementType,
+                    }),
+                    summary: "Enhanced EXPLAIN is limited to readonly SQL.",
+                });
+            }
+            const ctx = await resolveContext(input, deps, context, true);
+            const decision = await deps.engine.inspectSql({
+                toolName: "explain_sql_enhanced",
+                sql,
+                context: ctx,
+            });
+            if (decision.action === "block") {
+                return formatBlocked({
+                    reason: decision.riskHints[0] ?? "The SQL statement is blocked by safety policy.",
+                    metadata: metadata(context.taskId, {
+                        sql_hash: decision.sqlHash,
+                        statement_type: statementType,
+                    }),
+                    details: {
+                        risk_level: decision.riskLevel,
+                        reason_codes: decision.reasonCodes,
+                        risk_hints: decision.riskHints,
+                    },
+                });
+            }
+            const result = await deps.engine.explainEnhanced(sql, ctx);
+            return formatSuccess(toPublicEnhancedExplainResult(result, decision), {
+                summary: "Enhanced EXPLAIN generated.",
+                metadata: metadata(context.taskId, {
+                    sql_hash: decision.sqlHash,
+                    statement_type: statementType,
+                    duration_ms: result.standardPlan.durationMs,
+                }),
+            });
+        }
+        catch (error) {
+            return formatToolError(error, {
+                action: "explain_sql_enhanced",
+                metadata: metadata(context.taskId, {
+                    statement_type: statementType,
+                }),
+            });
+        }
+    },
+};

package/dist/tools/taurus/flashback.d.ts

@@ -0,0 +1,2 @@
+import type { ToolDefinition } from "../registry.js";
+export declare const flashbackQueryTool: ToolDefinition;

package/dist/tools/taurus/flashback.js

@@ -0,0 +1,101 @@
+import { z } from "zod";
+import { formatSuccess } from "../../utils/formatter.js";
+import { formatToolError } from "../error-handling.js";
+import { asOptionalPositiveInteger, asOptionalString, asRequiredString, contextInputShape, metadata, requireDatabase, resolveContext, summarizeRows, toPublicQueryResult, } from "../common.js";
+const asOfSchema = z
+    .object({
+    timestamp: z.string().trim().min(1).optional(),
+    relative: z.string().trim().min(1).optional(),
+})
+    .refine((value) => Boolean(value.timestamp) !== Boolean(value.relative), {
+    message: "Provide exactly one of as_of.timestamp or as_of.relative.",
+})
+    .describe("Flashback point in time. Use either an absolute timestamp or a relative duration like 5m.");
+function parseColumns(input) {
+    if (input === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(input)) {
+        throw new Error("Invalid columns: expected an array of strings.");
+    }
+    return input.map((value, index) => asRequiredString(value, `columns[${index}]`));
+}
+function parseAsOf(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        throw new Error("Invalid as_of: expected an object.");
+    }
+    const record = input;
+    const timestamp = asOptionalString(record.timestamp, "as_of.timestamp");
+    const relative = asOptionalString(record.relative, "as_of.relative");
+    if (Boolean(timestamp) === Boolean(relative)) {
+        throw new Error("Provide exactly one of as_of.timestamp or as_of.relative.");
+    }
+    if (timestamp) {
+        return { timestamp };
+    }
+    return { relative: relative };
+}
+export const flashbackQueryTool = {
+    name: "flashback_query",
+    description: "Run a TaurusDB flashback SELECT against a historical timestamp using the normal readonly execution path.",
+    inputSchema: {
+        ...contextInputShape,
+        table: z
+            .string()
+            .trim()
+            .min(1)
+            .describe("Table name to query historically."),
+        as_of: asOfSchema,
+        where: z
+            .string()
+            .trim()
+            .min(1)
+            .optional()
+            .describe("Optional SQL WHERE clause body."),
+        columns: z
+            .array(z.string().trim().min(1))
+            .optional()
+            .describe("Optional column projection."),
+        limit: z
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .describe("Maximum rows to return."),
+    },
+    async handler(input, deps, context) {
+        try {
+            const ctx = await resolveContext(input, deps, context, true);
+            const database = requireDatabase(input.database, ctx);
+            const table = asRequiredString(input.table, "table");
+            const result = await deps.engine.flashbackQuery({
+                database,
+                table,
+                asOf: parseAsOf(input.as_of),
+                where: asOptionalString(input.where, "where"),
+                columns: parseColumns(input.columns),
+                limit: asOptionalPositiveInteger(input.limit, "limit"),
+            }, ctx);
+            return formatSuccess({
+                datasource: ctx.datasource,
+                database,
+                table,
+                ...toPublicQueryResult(result),
+            }, {
+                summary: summarizeRows(result.rowCount, result.truncated),
+                metadata: metadata(context.taskId, {
+                    statement_type: "select",
+                    duration_ms: result.durationMs,
+                }),
+            });
+        }
+        catch (error) {
+            return formatToolError(error, {
+                action: "flashback_query",
+                metadata: metadata(context.taskId, {
+                    statement_type: "select",
+                }),
+            });
+        }
+    },
+};

package/dist/tools/taurus/recycle-bin.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from "../registry.js";
+export declare const listRecycleBinTool: ToolDefinition;
+export declare const restoreRecycleBinTableTool: ToolDefinition;

package/dist/tools/taurus/recycle-bin.js

@@ -0,0 +1,148 @@
+import { z } from "zod";
+import { buildRestoreRecycleBinTableSql, } from "taurusdb-core";
+import { ErrorCode, formatConfirmationRequired, formatError, formatSuccess, } from "../../utils/formatter.js";
+import { formatToolError } from "../error-handling.js";
+import { asOptionalString, asRequiredString, contextInputShape, metadata, resolveContext, summarizeMutation, summarizeRows, toPublicMutationResult, toPublicQueryResult, } from "../common.js";
+function parseRestoreMethod(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "native_restore" || value === "insert_select") {
+        return value;
+    }
+    throw new Error("Invalid method: expected native_restore or insert_select.");
+}
+export const listRecycleBinTool = {
+    name: "list_recycle_bin",
+    description: "List TaurusDB recycle bin tables. This is readonly and is intended for recovery triage after accidental DROP TABLE.",
+    inputSchema: {
+        datasource: contextInputShape.datasource,
+        timeout_ms: contextInputShape.timeout_ms,
+    },
+    async handler(input, deps, context) {
+        try {
+            const ctx = await resolveContext(input, deps, context, true);
+            const result = await deps.engine.listRecycleBin(ctx);
+            return formatSuccess({
+                datasource: ctx.datasource,
+                ...toPublicQueryResult(result),
+            }, {
+                summary: summarizeRows(result.rowCount, result.truncated),
+                metadata: metadata(context.taskId, {
+                    statement_type: "show",
+                    duration_ms: result.durationMs,
+                }),
+            });
+        }
+        catch (error) {
+            return formatToolError(error, {
+                action: "list_recycle_bin",
+                metadata: metadata(context.taskId, {
+                    statement_type: "show",
+                }),
+            });
+        }
+    },
+};
+export const restoreRecycleBinTableTool = {
+    name: "restore_recycle_bin_table",
+    description: "Restore a TaurusDB recycle bin table after explicit confirmation. Use insert_select for DRS/binlog-friendly recovery into a pre-created destination table.",
+    inputSchema: {
+        ...contextInputShape,
+        recycle_table: z
+            .string()
+            .trim()
+            .min(1)
+            .describe("Recycle bin table name returned by list_recycle_bin."),
+        method: z
+            .enum(["native_restore", "insert_select"])
+            .optional()
+            .describe("Restore method. native_restore calls dbms_recyclebin.restore_table; insert_select copies rows into a pre-created destination table."),
+        destination_database: z
+            .string()
+            .trim()
+            .min(1)
+            .optional()
+            .describe("Destination database. Required for insert_select; optional with native_restore when renaming on restore."),
+        destination_table: z
+            .string()
+            .trim()
+            .min(1)
+            .optional()
+            .describe("Destination table. Required for insert_select; optional with native_restore when renaming on restore."),
+        confirmation_token: z
+            .string()
+            .trim()
+            .min(1)
+            .optional()
+            .describe("Confirmation token returned by the first guarded restore call."),
+    },
+    async handler(input, deps, context) {
+        const restoreInput = {
+            recycleTable: asRequiredString(input.recycle_table, "recycle_table"),
+            method: parseRestoreMethod(input.method),
+            destinationDatabase: asOptionalString(input.destination_database, "destination_database"),
+            destinationTable: asOptionalString(input.destination_table, "destination_table"),
+        };
+        try {
+            const ctx = await resolveContext(input, deps, context, false);
+            const sql = buildRestoreRecycleBinTableSql(restoreInput);
+            const responseMetadata = metadata(context.taskId, {
+                statement_type: restoreInput.method === "insert_select" ? "insert" : "unknown",
+            });
+            const confirmationToken = asOptionalString(input.confirmation_token, "confirmation_token");
+            if (confirmationToken) {
+                const validation = await deps.engine.validateConfirmation(confirmationToken, sql, ctx);
+                if (!validation.valid) {
+                    return formatError({
+                        code: ErrorCode.CONFIRMATION_INVALID,
+                        message: validation.reason ?? "Confirmation token validation failed.",
+                        summary: "The provided confirmation token is invalid for this recycle bin restore.",
+                        metadata: responseMetadata,
+                        details: {
+                            reason_codes: validation.reasonCodes,
+                            risk_hints: validation.riskHints,
+                        },
+                    });
+                }
+            }
+            else {
+                const token = await deps.engine.issueConfirmation({
+                    sql,
+                    context: ctx,
+                    riskLevel: "high",
+                });
+                return formatConfirmationRequired({
+                    confirmationToken: token.token,
+                    metadata: responseMetadata,
+                    riskLevel: "high",
+                    summary: "Recycle bin restore requires explicit confirmation.",
+                    message: "Re-run restore_recycle_bin_table with the same input and confirmation_token to continue.",
+                });
+            }
+            const result = await deps.engine.restoreRecycleBinTable(restoreInput, ctx);
+            return formatSuccess({
+                datasource: ctx.datasource,
+                recycle_table: restoreInput.recycleTable,
+                method: restoreInput.method ?? "native_restore",
+                destination_database: restoreInput.destinationDatabase,
+                destination_table: restoreInput.destinationTable,
+                ...toPublicMutationResult(result),
+            }, {
+                summary: summarizeMutation(result.affectedRows),
+                metadata: metadata(context.taskId, {
+                    statement_type: restoreInput.method === "insert_select" ? "insert" : "unknown",
+                    duration_ms: result.durationMs,
+                }),
+            });
+        }
+        catch (error) {
+            return formatToolError(error, {
+                action: "restore_recycle_bin_table",
+                metadata: metadata(context.taskId, {
+                    statement_type: restoreInput.method === "insert_select" ? "insert" : "unknown",
+                }),
+            });
+        }
+    },
+};

package/dist/utils/formatter.d.ts

@@ -0,0 +1,5 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { ToolResponse } from "taurusdb-core";
+export { ErrorCode, formatBlocked, formatConfirmationRequired, formatError, formatSuccess, } from "taurusdb-core";
+export type { ResponseMetadata, ToolError, ToolResponse, } from "taurusdb-core";
+export declare function toMcpToolResult<T>(response: ToolResponse<T>): CallToolResult;

package/dist/utils/formatter.js

@@ -0,0 +1,8 @@
+export { ErrorCode, formatBlocked, formatConfirmationRequired, formatError, formatSuccess, } from "taurusdb-core";
+export function toMcpToolResult(response) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(response) }],
+        structuredContent: response,
+        isError: !response.ok,
+    };
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "0.1.0";

package/dist/version.js

@@ -0,0 +1 @@
+export const VERSION = "0.1.0";