@stelis/say-ur-intent 0.0.0 → 0.0.2

package/dist/mcp/tools/read/reviewActivityTools.js

@@ -0,0 +1,176 @@
+import { z } from "zod";
+import { actionPlanSchema, executionResultSchema, internalSessionStatusSchema, reviewStateOutputSchema, unknownRecordSchema } from "../../../core/action/schemas.js";
+import { REVIEW_ACTIVITY_LIST_DEFAULT_LIMIT, REVIEW_ACTIVITY_LIST_MAX_LIMIT, REVIEW_ACTIVITY_LOW_SAMPLE_THRESHOLD } from "../../../core/activity/activityStore.js";
+import { successOutputSchema } from "../../schemas.js";
+import { okToolResult } from "../../result.js";
+import { TOOL_NAMES } from "../../toolNames.js";
+import { reviewActivityListUserAnswerUse, reviewFunnelUserAnswerUse, reviewSessionDetailUserAnswerUse } from "../../responseGuidance.js";
+import { fetchedAtSchema, reviewActivityAccountSourceSchema, reviewActivityDataScopeSchema, reviewActivityInputSchema, userAnswerUseSchema } from "./commonSchemas.js";
+import { activityStoreReadError } from "./readToolHelpers.js";
+const reviewActivityCommonOutput = {
+    dataScope: reviewActivityDataScopeSchema,
+    accountSource: reviewActivityAccountSourceSchema,
+    userAnswerUse: userAnswerUseSchema,
+    lowSampleWarning: z.boolean(),
+    lowSampleThreshold: z.literal(REVIEW_ACTIVITY_LOW_SAMPLE_THRESHOLD),
+    truncated: z.object({
+        activities: z.boolean(),
+        snapshots: z.boolean(),
+        transitions: z.boolean()
+    })
+};
+const reviewActivityRowSchema = z.object({
+    reviewSessionId: z.string(),
+    planId: z.string(),
+    actionKind: z.string(),
+    adapterId: z.string(),
+    protocol: z.string(),
+    currentStatus: internalSessionStatusSchema,
+    account: z.string(),
+    createdAt: fetchedAtSchema,
+    updatedAt: fetchedAtSchema,
+    executionStatus: z.string().optional(),
+    txDigest: z.string().optional(),
+    snapshotCount: z.number().int().nonnegative(),
+    transitionCount: z.number().int().nonnegative()
+});
+export function registerReviewActivityListTool(server, deps) {
+    server.registerTool(TOOL_NAMES.readListReviewActivity, {
+        title: "List review activity",
+        description: "List local Say Ur Intent review-session records for one account. Not wallet transaction history.",
+        inputSchema: {
+            ...reviewActivityInputSchema,
+            status: internalSessionStatusSchema.optional(),
+            limit: z.number().int().min(1).max(REVIEW_ACTIVITY_LIST_MAX_LIMIT).optional()
+        },
+        outputSchema: successOutputSchema({
+            ...reviewActivityCommonOutput,
+            activities: z.array(reviewActivityRowSchema)
+        }),
+        annotations: { readOnlyHint: true, openWorldHint: false }
+    }, async ({ account, from, to, status, limit }) => {
+        try {
+            const result = await deps.activityStore.listReviewActivity({
+                account,
+                from,
+                to,
+                status,
+                limit: limit ?? REVIEW_ACTIVITY_LIST_DEFAULT_LIMIT
+            });
+            return okToolResult({
+                ...result,
+                userAnswerUse: reviewActivityListUserAnswerUse()
+            });
+        }
+        catch (error) {
+            return activityStoreReadError(error, deps);
+        }
+    });
+}
+export function registerReviewActivitySummaryTools(server, deps) {
+    server.registerTool(TOOL_NAMES.readSummarizeReviewFunnel, {
+        title: "Summarize review funnel",
+        description: "Lifecycle counts for local Say Ur Intent review sessions in one account scope.",
+        inputSchema: reviewActivityInputSchema,
+        outputSchema: successOutputSchema({
+            ...reviewActivityCommonOutput,
+            summary: z.object({
+                total: z.number().int().nonnegative(),
+                opened: z.number().int().nonnegative(),
+                walletConnected: z.number().int().nonnegative(),
+                stateComputed: z.number().int().nonnegative(),
+                currentStatusCounts: unknownRecordSchema,
+                everReachedReviewStateCounts: z.object({
+                    ready_for_wallet_review: z.number().int().nonnegative(),
+                    blocked: z.number().int().nonnegative(),
+                    refresh_required: z.number().int().nonnegative()
+                }),
+                signedPending: z.number().int().nonnegative(),
+                success: z.number().int().nonnegative(),
+                failure: z.number().int().nonnegative(),
+                expiredBeforeResult: z.number().int().nonnegative(),
+                avgCreatedToSignedSeconds: z.number().nullable(),
+                avgOpenedToSignedSeconds: z.number().nullable()
+            })
+        }),
+        annotations: { readOnlyHint: true, openWorldHint: false }
+    }, async ({ account, from, to }) => {
+        try {
+            const result = await deps.activityStore.summarizeReviewFunnel({ account, from, to });
+            return okToolResult({
+                ...result,
+                userAnswerUse: reviewFunnelUserAnswerUse()
+            });
+        }
+        catch (error) {
+            return activityStoreReadError(error, deps);
+        }
+    });
+    server.registerTool(TOOL_NAMES.readGetReviewSessionDetail, {
+        title: "Get review session detail",
+        description: "Return one stored Say Ur Intent review session with plan, snapshots, transitions, and result.",
+        inputSchema: {
+            reviewSessionId: z.string().min(1),
+            account: z.string().min(1).optional()
+        },
+        outputSchema: successOutputSchema({
+            ...reviewActivityCommonOutput,
+            session: reviewActivityRowSchema.omit({
+                executionStatus: true,
+                txDigest: true,
+                snapshotCount: true,
+                transitionCount: true
+            }),
+            planJson: actionPlanSchema,
+            intentJson: z.unknown().optional(),
+            stateSnapshots: z.array(z.object({
+                id: z.number().int().positive(),
+                planId: z.string(),
+                account: z.string(),
+                status: z.string(),
+                blockedReason: z.string().optional(),
+                refreshReason: z.string().optional(),
+                stateJson: reviewStateOutputSchema,
+                updatedAt: fetchedAtSchema,
+                recordedAt: fetchedAtSchema
+            })),
+            transitions: z.array(z.object({
+                id: z.number().int().positive(),
+                event: z.string(),
+                fromStatus: z.string().optional(),
+                toStatus: z.string(),
+                isNoOp: z.boolean(),
+                account: z.string().optional(),
+                reason: z.string().optional(),
+                transitionedAt: fetchedAtSchema
+            })),
+            execution: z
+                .object({
+                reviewSessionId: z.string(),
+                planId: z.string(),
+                accountId: z.number().int().positive(),
+                account: z.string(),
+                status: z.string(),
+                txDigest: z.string().optional(),
+                explorerUrl: z.string().optional(),
+                failureReason: z.string().optional(),
+                recordedAt: fetchedAtSchema,
+                updatedAt: fetchedAtSchema,
+                resultJson: executionResultSchema
+            })
+                .optional()
+        }),
+        annotations: { readOnlyHint: true, openWorldHint: false }
+    }, async ({ reviewSessionId, account }) => {
+        try {
+            const result = await deps.activityStore.getReviewSessionDetail({ reviewSessionId, account });
+            return okToolResult({
+                ...result,
+                userAnswerUse: reviewSessionDetailUserAnswerUse(result.execution !== undefined)
+            });
+        }
+        catch (error) {
+            return activityStoreReadError(error, deps);
+        }
+    });
+}

package/dist/mcp/tools/read/serverStatusTools.js

@@ -0,0 +1,103 @@
+import { z } from "zod";
+import { noParamsInputSchema, successOutputSchema } from "../../schemas.js";
+import { okToolResult } from "../../result.js";
+import { MCP_PROMPTS } from "../../prompts.js";
+import { MCP_RESOURCES } from "../../resources.js";
+import { EVIDENCE_POLICY, FAIL_CLOSED_TOOLS, IMPLEMENTED_TOOLS, PACKAGE_NAME, SERVER_LIMITATIONS, SERVER_NAME, SERVER_NETWORK, SERVER_RUNTIME, SERVER_TRANSPORT, SERVER_VERSION } from "../../serverInfo.js";
+import { TOOL_NAMES } from "../../toolNames.js";
+// Listed swap-capable DeFi venues first, in selection order (deep, then flowx),
+// so protocol enumeration leads with the venues a user actually picks between.
+// deepbook-margin is protocol-notes-only (no swap surface) and trails them.
+export const SUPPORTED_PROTOCOLS = [
+    { id: "deepbook-v3", status: "mainnet", support: "read_and_local_review" },
+    { id: "flowx-clmm", status: "mainnet", support: "read_and_local_review" },
+    { id: "deepbook-margin", status: "mainnet", support: "protocol_notes_only" }
+];
+export function registerServerStatusTools(server) {
+    server.registerTool(TOOL_NAMES.readGetServerStatus, {
+        title: "Get server status",
+        description: "Return package, runtime, tool, resource, and prompt status.",
+        inputSchema: noParamsInputSchema,
+        outputSchema: successOutputSchema({
+            packageName: z.string(),
+            serverName: z.string(),
+            version: z.string(),
+            evidencePolicy: z.object({
+                version: z.string(),
+                releaseGate: z.literal("intent_evidence_v1"),
+                requiredFirstCheck: z.literal(true),
+                requiredStatusFields: z.array(z.string()),
+                gates: z.array(z.string())
+            }),
+            network: z.literal("mainnet"),
+            runtime: z.literal("local_stdio"),
+            transport: z.literal("grpc_graphql"),
+            implementedTools: z.array(z.string()),
+            implementedToolsCount: z.number().int().nonnegative(),
+            failClosedTools: z.array(z.string()),
+            resources: z.object({
+                count: z.number().int().nonnegative(),
+                uris: z.array(z.string()),
+                items: z.array(z.object({
+                    name: z.string(),
+                    uri: z.string(),
+                    title: z.string(),
+                    description: z.string()
+                }))
+            }),
+            prompts: z.object({
+                count: z.number().int().nonnegative(),
+                names: z.array(z.string())
+            }),
+            protocolsTool: z.literal("read.list_supported_protocols"),
+            limitations: z.array(z.string())
+        }),
+        annotations: { readOnlyHint: true, openWorldHint: false }
+    }, async () => okToolResult({
+        packageName: PACKAGE_NAME,
+        serverName: SERVER_NAME,
+        version: SERVER_VERSION,
+        evidencePolicy: {
+            ...EVIDENCE_POLICY,
+            requiredStatusFields: [...EVIDENCE_POLICY.requiredStatusFields],
+            gates: [...EVIDENCE_POLICY.gates]
+        },
+        network: SERVER_NETWORK,
+        runtime: SERVER_RUNTIME,
+        transport: SERVER_TRANSPORT,
+        implementedTools: [...IMPLEMENTED_TOOLS],
+        implementedToolsCount: IMPLEMENTED_TOOLS.length,
+        failClosedTools: [...FAIL_CLOSED_TOOLS],
+        resources: {
+            count: MCP_RESOURCES.length,
+            uris: MCP_RESOURCES.map((resource) => resource.uri),
+            items: MCP_RESOURCES.map((resource) => ({
+                name: resource.name,
+                uri: resource.uri,
+                title: resource.title,
+                description: resource.description
+            }))
+        },
+        prompts: {
+            count: MCP_PROMPTS.length,
+            names: MCP_PROMPTS.map((prompt) => prompt.name)
+        },
+        protocolsTool: TOOL_NAMES.readListSupportedProtocols,
+        limitations: [...SERVER_LIMITATIONS]
+    }));
+    server.registerTool(TOOL_NAMES.readListSupportedProtocols, {
+        title: "List supported protocols",
+        description: "List current mainnet protocol surfaces and support levels.",
+        inputSchema: noParamsInputSchema,
+        outputSchema: successOutputSchema({
+            protocols: z.array(z.object({
+                id: z.string(),
+                status: z.literal("mainnet"),
+                support: z.string()
+            }))
+        }),
+        annotations: { readOnlyHint: true, openWorldHint: false }
+    }, async () => okToolResult({
+        protocols: [...SUPPORTED_PROTOCOLS]
+    }));
+}

package/dist/mcp/tools/read/transactionActivityOutput.js

@@ -0,0 +1,300 @@
+import { compactExternalActivityTransactionDetails } from "../../../core/activity/transactionActivityDetails.js";
+import { TOOL_NAMES } from "../../toolNames.js";
+export const SUI_ACTIVITY_QUANTITY_SEMANTICS = {
+    kind: "sui_activity_raw_amounts",
+    rawAmountsOnly: true,
+    displayConversionRequires: "verified_coin_metadata_decimals",
+    gasRawUnit: "MIST",
+    gasUnitSource: "@mysten/sui MIST_PER_SUI",
+    gasDisplayFields: [
+        "transaction.compact.gasCost.display",
+        "requestedAccountTransactionFacts[].transactionContext.gasCost.display",
+        "transactions[].transactionContext.gasCost.display",
+        "analysis.gas.netGasCost.display"
+    ],
+    rawAmountFields: [
+        "transaction.details.balanceChanges[].amountRaw",
+        "transaction.requestedAccountEffect.balanceChanges[].amountRaw",
+        "transaction.requestedAccountEffect.coinFlows[].*Raw",
+        "requestedAccount.coinFlows[].*Raw",
+        "requestedAccountTransactionFacts[].accountBalanceChanges[].amountRaw",
+        "requestedAccountTransactionFacts[].accountCoinFlows[].*Raw",
+        "requestedAccountTransactionFacts[].requestedAccountEffect.balanceChanges[].amountRaw",
+        "requestedAccountTransactionFacts[].requestedAccountEffect.coinFlows[].*Raw",
+        "transactions[].requestedAccountEffect.balanceChanges[].amountRaw",
+        "transactions[].requestedAccountEffect.coinFlows[].*Raw",
+        "transactions[].details.balanceChanges[].amountRaw",
+        "transactions[].compact.balanceChanges[].amountRaw",
+        "analysis.coinFlows[].*Raw"
+    ],
+    notFor: [
+        "display_conversion_without_verified_decimals",
+        "fiat_usd_cash_out",
+        "profit_or_pnl",
+        "position_valuation"
+    ]
+};
+export function suiActivityQuantitySemantics() {
+    return SUI_ACTIVITY_QUANTITY_SEMANTICS;
+}
+export function transactionDetailAvailability(transactions) {
+    const totalTransactions = transactions.length;
+    const withDetails = transactions.filter((transaction) => transaction.details !== undefined).length;
+    const withoutDetails = totalTransactions - withDetails;
+    const detailAvailability = withDetails === 0 ? "none" : withoutDetails === 0 ? "all" : "some";
+    return {
+        totalTransactions,
+        withDetails,
+        withoutDetails,
+        detailAvailability,
+        allReturnedTransactionsHaveDetails: detailAvailability === "all"
+    };
+}
+function normalizeDetailAvailability(input) {
+    if (typeof input !== "string") {
+        return input;
+    }
+    return {
+        totalTransactions: input === "some" ? 2 : input === "none" ? 0 : 1,
+        withDetails: input === "none" ? 0 : 1,
+        withoutDetails: input === "some" ? 1 : 0,
+        detailAvailability: input,
+        allReturnedTransactionsHaveDetails: input === "all"
+    };
+}
+export function inspectSuiTransactionUserAnswerUse(fields = {}) {
+    const hasSender = fields.hasSender ?? true;
+    const hasRequestedAccountEffect = fields.hasRequestedAccountEffect ?? true;
+    const hasDetails = fields.hasDetails ?? true;
+    return {
+        canAnswer: [
+            "one_sui_transaction_digest_status_and_context",
+            ...(hasRequestedAccountEffect ? ["requested_account_balance_effect_for_this_digest"] : []),
+            ...(hasDetails ? ["transaction_level_move_call_object_event_gas_and_protocol_label_facts"] : [])
+        ],
+        cannotAnswer: [
+            "complete_wallet_history",
+            ...(hasRequestedAccountEffect ? [] : ["requested_account_balance_effect_without_requestedAccountEffect_field"]),
+            ...(hasDetails ? [] : ["transaction_level_move_call_object_event_gas_and_protocol_label_facts_without_details_field"]),
+            "display_token_amounts_without_verified_decimals",
+            "fiat_usd_cash_out",
+            "profit_or_pnl",
+            "position_valuation",
+            "route_recommendation",
+            "transaction_building",
+            "signing_data_or_readiness"
+        ],
+        answerFields: [
+            "transaction.digest",
+            "transaction.status",
+            ...(hasSender ? ["transaction.sender"] : []),
+            ...(hasRequestedAccountEffect ? ["transaction.requestedAccountEffect"] : []),
+            ...(hasDetails ? ["transaction.compact", "transaction.details"] : []),
+            "fetchedAt"
+        ],
+        diagnosticOnlyFields: ["source", "quantitySemantics", "persistence"]
+    };
+}
+export function liveSuiActivityUserAnswerUse(input) {
+    const includeAnalysis = typeof input === "boolean" ? input : input.includeAnalysis;
+    const detailAvailability = normalizeDetailAvailability(typeof input === "boolean" ? "all" : input.transactionDetailAvailability ?? "all");
+    const allTransactionsHaveContext = detailAvailability.allReturnedTransactionsHaveDetails;
+    const someTransactionsHaveContext = detailAvailability.withDetails > 0;
+    return {
+        canAnswer: [
+            "bounded_requested_account_activity_page",
+            "requested_account_raw_coin_flows_in_returned_rows",
+            "transaction_detail_availability_for_returned_rows",
+            ...(allTransactionsHaveContext ? ["transaction_context_for_all_returned_rows"] : []),
+            ...(!allTransactionsHaveContext && someTransactionsHaveContext
+                ? ["transaction_context_for_some_returned_rows"]
+                : []),
+            ...(includeAnalysis ? ["deterministic_summary_over_returned_normalized_rows"] : [])
+        ],
+        cannotAnswer: [
+            "complete_wallet_history",
+            "complete_dapp_history",
+            ...(allTransactionsHaveContext ? [] : ["transaction_context_for_all_returned_rows_without_all_details"]),
+            "display_token_amounts_without_verified_decimals",
+            "fiat_usd_cash_out",
+            "profit_or_pnl",
+            "position_valuation",
+            "route_recommendation",
+            "transaction_building",
+            "signing_data_or_readiness"
+        ],
+        answerFields: [
+            "requestedAccount",
+            "requestedAccountTransactionFacts",
+            "requestedAccountTransactionFacts[].requestedAccountEffect",
+            "requestedAccountTransactionFacts[].accountCoinFlows",
+            "transactionDetailAvailability",
+            ...(allTransactionsHaveContext ? ["transactions[].transactionContext"] : []),
+            ...(includeAnalysis ? ["analysis"] : []),
+            "fetchedAt"
+        ],
+        conclusionRuleFields: ["transactionDetailAvailability"],
+        diagnosticOnlyFields: [
+            "source",
+            "quantitySemantics",
+            "persistence",
+            "hasMore",
+            "continuationCursor",
+            "windowComplete",
+            "orderingVerified",
+            "incompleteReason"
+        ],
+        followUp: {
+            tool: TOOL_NAMES.readInspectSuiTransaction,
+            inputFields: ["transactions[].detailLookup.digest"],
+            answerFields: ["transaction"],
+            reason: "Use when the user asks for full normalized details for a returned digest; scan rows intentionally omit full details."
+        }
+    };
+}
+export function storedSuiActivityUserAnswerUse(input = "all") {
+    const detailAvailability = normalizeDetailAvailability(input);
+    const allTransactionsHaveDetails = detailAvailability.allReturnedTransactionsHaveDetails;
+    const someTransactionsHaveDetails = detailAvailability.withDetails > 0;
+    return {
+        canAnswer: [
+            "stored_local_normalized_activity_summary_for_the_selected_account",
+            "deterministic_summary_over_stored_normalized_rows",
+            "stored_transaction_detail_availability_for_returned_rows",
+            ...(allTransactionsHaveDetails ? ["stored_transaction_context_for_all_returned_rows"] : []),
+            ...(!allTransactionsHaveDetails && someTransactionsHaveDetails
+                ? ["stored_transaction_context_for_some_returned_rows"]
+                : [])
+        ],
+        cannotAnswer: [
+            "live_latest_activity",
+            "complete_wallet_history",
+            "complete_dapp_history",
+            ...(allTransactionsHaveDetails ? [] : ["stored_transaction_context_for_all_returned_rows_without_all_details"]),
+            "display_token_amounts_without_verified_decimals",
+            "fiat_usd_cash_out",
+            "profit_or_pnl",
+            "position_valuation",
+            "route_recommendation",
+            "transaction_building",
+            "signing_data_or_readiness"
+        ],
+        answerFields: [
+            "summary",
+            "analysis",
+            "transactions",
+            "transactionDetailAvailability",
+            ...(allTransactionsHaveDetails ? ["transactions[].compact", "transactions[].details"] : [])
+        ],
+        conclusionRuleFields: ["transactionDetailAvailability"],
+        diagnosticOnlyFields: [
+            "dataScope",
+            "accountSource",
+            "lowSampleWarning",
+            "lowSampleThreshold",
+            "truncated",
+            "source",
+            "quantitySemantics"
+        ],
+        followUp: {
+            tool: TOOL_NAMES.readSummarizeSuiActivityScan,
+            inputFields: ["dataScope.account"],
+            answerFields: ["requestedAccountTransactionFacts", "analysis"],
+            reason: "Use for recent live requested-account activity; stored summaries are local facts only."
+        }
+    };
+}
+export function transactionFactOutput(transaction) {
+    const { accountEffects } = transaction;
+    return {
+        digest: transaction.digest,
+        ...(transaction.checkpoint === undefined ? {} : { checkpoint: transaction.checkpoint }),
+        ...(transaction.timestamp === undefined ? {} : { timestamp: transaction.timestamp }),
+        status: transaction.status,
+        ...(transaction.sender === undefined ? {} : { sender: transaction.sender }),
+        ...(accountEffects === undefined ? {} : { requestedAccountEffect: accountEffects }),
+        ...(transaction.details === undefined
+            ? {}
+            : { compact: compactExternalActivityTransactionDetails(transaction.details) }),
+        ...(transaction.details === undefined ? {} : { details: transaction.details })
+    };
+}
+export function transactionFactAuditOutput(transaction) {
+    const { accountEffects } = transaction;
+    return {
+        digest: transaction.digest,
+        ...(transaction.checkpoint === undefined ? {} : { checkpoint: transaction.checkpoint }),
+        ...(transaction.timestamp === undefined ? {} : { timestamp: transaction.timestamp }),
+        status: transaction.status,
+        ...(transaction.sender === undefined ? {} : { sender: transaction.sender }),
+        ...(accountEffects === undefined ? {} : { requestedAccountEffect: accountEffects }),
+        ...(transaction.details === undefined
+            ? {}
+            : { transactionContext: transactionContextOutput(compactExternalActivityTransactionDetails(transaction.details)) }),
+        detailLookup: {
+            tool: TOOL_NAMES.readInspectSuiTransaction,
+            digest: transaction.digest
+        }
+    };
+}
+export function requestedAccountTransactionFactOutput(transaction) {
+    if (transaction.accountEffects === undefined) {
+        return undefined;
+    }
+    const compact = transaction.details === undefined
+        ? undefined
+        : compactExternalActivityTransactionDetails(transaction.details);
+    const transactionContext = compact === undefined
+        ? undefined
+        : transactionContextOutput(compact);
+    return {
+        digest: transaction.digest,
+        ...(transaction.checkpoint === undefined ? {} : { checkpoint: transaction.checkpoint }),
+        ...(transaction.timestamp === undefined ? {} : { timestamp: transaction.timestamp }),
+        status: transaction.status,
+        ...(transaction.sender === undefined ? {} : { sender: transaction.sender }),
+        requestedAccount: transaction.accountEffects.account,
+        accountScope: transaction.accountEffects.scope,
+        accountRole: transaction.accountEffects.role,
+        sentByAccount: transaction.accountEffects.sentByAccount,
+        accountBalanceChangeEvidence: transaction.accountEffects.balanceChangeEvidence,
+        accountBalanceChangeAbsenceProven: transaction.accountEffects.accountBalanceChangeAbsenceProven,
+        accountBalanceChangeInferencePolicy: transaction.accountEffects.accountBalanceChangeInferencePolicy,
+        accountBalanceChangeCompleteness: transaction.accountEffects.balanceChangeCompleteness,
+        accountBalanceChanges: transaction.accountEffects.balanceChanges,
+        accountCoinFlows: transaction.accountEffects.coinFlows,
+        accountEffectLimitations: transaction.accountEffects.limitations,
+        requestedAccountEffect: transaction.accountEffects,
+        ...(transactionContext === undefined ? {} : { transactionContext }),
+        detailLookup: {
+            tool: TOOL_NAMES.readInspectSuiTransaction,
+            digest: transaction.digest
+        }
+    };
+}
+function transactionContextOutput(compact) {
+    return {
+        factScope: compact.factScope,
+        requestedAccountScoped: compact.requestedAccountScoped,
+        moveCallTargets: compact.moveCallTargets,
+        objectChangeCounts: compact.objectChangeCounts,
+        eventTypes: compact.eventTypes,
+        ...(compact.gasCost === undefined ? {} : { gasCost: compact.gasCost }),
+        ...(compact.gasNetCostRaw === undefined ? {} : { gasNetCostRaw: compact.gasNetCostRaw }),
+        ...(compact.executionError === undefined ? {} : { executionError: compact.executionError }),
+        detailTruncated: compact.detailTruncated,
+        ...(compact.protocolMatches === undefined ? {} : { protocolMatches: compact.protocolMatches })
+    };
+}
+export function externalActivityTransactionRecordOutput(transaction) {
+    return {
+        ...transaction,
+        ...(transaction.details === undefined
+            ? {}
+            : { compact: compactExternalActivityTransactionDetails(transaction.details) }),
+        detailLookup: {
+            tool: TOOL_NAMES.readInspectSuiTransaction,
+            digest: transaction.digest
+        }
+    };
+}