wowok_agent 1.6.6 → 2.1.9

package/dist/index.js

@@ -1,27 +1,1026 @@
-export * from './query/objects.js';
-export * from './query/permission.js';
-export * from './query/events.js';
-export * from './call/base.js';
-export * from './call/permission.js';
-export * from './call/arbitration.js';
-export * from './call/treasury.js';
-export * from './call/object_permission.js';
-export * from './call/demand.js';
-export * from './call/machine.js';
-export * from './call/repository.js';
-export * from './call/service.js';
-export * from './call/guard.js';
-export * from './call/personal.js';
-export * from './call/call.js';
-export * from './local/account.js';
-export * from './local/cache.js';
-export * from './local/local.js';
-export * from './local/index.js';
-export * from './common.js';
-export * from './query/received.js';
-export * from './schema/query.js';
-export * from './schema/call.js';
-export * from './schema/util.js';
-export * from './schema/local.js';
-export * as WOWOK from 'wowok';
-//# sourceMappingURL=index.js.map
+#!/usr/bin/env node
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import packageJson from "../package.json" with { type: "json" };
+// Import schema
+import { CallService_DataSchema, CallMachine_DataSchema, MachineNode2File_InputSchema, MachineNode2File_OutputWrappedSchema, CallProgress_DataSchema, CallPermission_DataSchema, CallGuard_DataSchema, Guard2File_InputSchema, Guard2File_OutputWrappedSchema, CallArbitration_DataSchema, CallRepository_DataSchema, CallContact_DataSchema, CallTreasury_DataSchema, CallReward_DataSchema, CallAllocation_DataSchema, CallPersonal_DataSchema, CallPayment_DataSchema, CallDemand_DataSchema, CallOrder_DataSchema, CallEnvSchema, SubmissionCallSchema, strictParse, CallOutputSchema, handleCallResult, createServerConfig, createCapabilitiesConfig, createToolMeta, transformSubmission, getEnvConfig, WipGenerationOptionsSchema, WipToHtmlOptionsSchema, TokenDataFilterSchema, LocalInfoFilterSchema, LocalMarkFilterSchema, AccountFilterSchema, TokenTypeSchema, OnchainEventsInputSchema, OnchainEventsResultSchema, ProtocolInfoQuerySchema, ProtocolInfoResultSchema, WatchQueryOperationsResultSchema, NameOrAddressSchema, AccountOrMark_AddressSchema, ObjectTypeSchema, AccountOperationOutputWrappedSchema, LocalMarkOperationOutputWrappedSchema, LocalInfoOperationOutputWrappedSchema, WipOperationOutputSchema, MessengerOperationOutputSchema, AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, parseMachineNodesFromText, formatNodeErrors as formatMachineNodeErrors, MessengerOperationInputSchema, } from "./schema/index.js";
+// Import wowok SDK
+import { CallService, CallMachine, CallProgress, CallPermission, CallGuard, CallArbitration, CallRepository, CallContact, CallTreasury, CallReward, CallAllocation, CallPersonal, CallPayment, CallDemand, CallOrder, gen_passport, guard2file, parseGuardFile, formatGuardParseErrors, machineNode2file, generate_wip, verify_wip, sign_wip, wip2html, account_operation, local_mark_operation, local_info_operation, watch_conversations, send_message, send_file, watch_messages, extract_zip_messages, generate_wts, verify_wts, sign_wts, wts2html, proof_message, query_local_mark_list, query_account_list, query_local_info_list, query_local_token_list, query_account, query_personal, query_objects, query_table, queryProtocolInfo, query_received, queryTableItem_RepositoryData, queryTableItem_PermissionPerm, queryTableItem_RewardRecord, queryTableItem_DemandPresenter, queryTableItem_TreasuryHistory, queryTableItem_MachineNode, queryTableItem_ProgressHistory, queryTableItem_AddressMark, queryTableItem_EntityRegistrar, queryTableItem_EntityLinker, query_events, } from "wowok";
+// TODO: Uncomment these once agent/mcp can import these properly
+// import {
+//     blacklist, friendslist, guardlist,
+// } from "wowok";
+// Create server instance
+const server = new McpServer(createServerConfig(packageJson), createCapabilitiesConfig());
+// ================================================
+// Schema Definitions
+// ================================================
+// On-chain Operations Schema (Merged from Merchant and Personal Operations)
+const OnchainOperationsSchema = z.discriminatedUnion("operation_type", [
+    // Merchant Operations
+    z.object({
+        operation_type: z.literal("service"),
+        data: CallService_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("🏪 Service Object: Create and manage product/service listings with transparent promises, bind workflow templates to order processing, set pricing, issue discount coupons to customers, and establish quality standards, etc.."),
+    z.object({
+        operation_type: z.literal("machine"),
+        data: CallMachine_DataSchema,
+        json_or_markdown_file: z.string().optional().describe("Path to a JSON or Markdown file containing the node definition. File content will be parsed and used to set nodes. If parsing fails, error will include line number and node information."),
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("⚙️ Machine Object: Design and deploy automated workflow templates (Machines) that define how services are delivered, etc.."),
+    z.object({
+        operation_type: z.literal("progress"),
+        data: CallProgress_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("📊 Progress Object: Track and manage active workflows in real-time."),
+    z.object({
+        operation_type: z.literal("repository"),
+        data: CallRepository_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("📦 Repository Object: Read/write database with consensus field + address as key, strongly-typed data as value."),
+    z.object({
+        operation_type: z.literal("arbitration"),
+        data: CallArbitration_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("⚖️ Arbitration Object: Access a transparent on-chain arbitration system for resolving order conflicts."),
+    z.object({
+        operation_type: z.literal("contact"),
+        data: CallContact_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("💬 Contact Object: Manage on-chain instant messaging contact profiles."),
+    z.object({
+        operation_type: z.literal("treasury"),
+        data: CallTreasury_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("💰 Treasury Object: Create and manage treasury for team funds with deposit/withdrawal rules, etc.."),
+    z.object({
+        operation_type: z.literal("reward"),
+        data: CallReward_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("🎁 Reward Object: Create reward pools and set claim conditions by Guard verification."),
+    z.object({
+        operation_type: z.literal("allocation"),
+        data: CallAllocation_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("📤 Allocation Object: Create distribution plans to auto-distribute funds to multiple recipients."),
+    z.object({
+        operation_type: z.literal("permission"),
+        data: CallPermission_DataSchema,
+        env: CallEnvSchema.optional(),
+    }).describe("🔐 Permission Object: Define who can perform which operations on WoWok objects. Important Note: If needed, you should first query 'guard instructions' through the 'wowok_buildin_info' tool."),
+    z.object({
+        operation_type: z.literal("guard"),
+        data: CallGuard_DataSchema,
+        env: CallEnvSchema.optional(),
+    }).describe("🛡️ Guard Object: Create immutable programmable validation rules that return boolean results. Set 'namedNew' to name the new Guard. Use root.type='node' for direct node tree or root.type='file' to load from file. Use 'wowok_buildin_info' tool with query='guard instructions' for all available operations."),
+    // Personal Operations
+    z.object({
+        operation_type: z.literal("personal"),
+        data: CallPersonal_DataSchema,
+        env: CallEnvSchema.optional(),
+    }).describe("🆔 Public Identity Profile: Establish and manage your on-chain public identity. ⚠️ CRITICAL: Everything here is PERMANENTLY PUBLIC on the blockchain!"),
+    z.object({
+        operation_type: z.literal("payment"),
+        data: CallPayment_DataSchema,
+        env: CallEnvSchema.optional(),
+    }).describe("💰 Payment Object: Send instant, irreversible coin transfers to any wallet address."),
+    z.object({
+        operation_type: z.literal("demand"),
+        data: CallDemand_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("🎯 Demand Object: Post service requests with reward pools on-chain."),
+    z.object({
+        operation_type: z.literal("order"),
+        data: CallOrder_DataSchema,
+        env: CallEnvSchema.optional(),
+        submission: SubmissionCallSchema.optional(),
+    }).describe("📦 Order Object: Manage the order lifecycle, Including operating order arbitration (Arb Object associated with the order), advancing progress (Progress Object associated with the order), extracting order refunds/payments, setting agents, etc."),
+    z.object({
+        operation_type: z.literal("gen_passport"),
+        guard: z.string().describe("Guard object ID to verify and generate passport from"),
+        info: SubmissionCallSchema.optional().describe("Optional submission data. If not provided, will attempt to get existing submissions from the guard."),
+        env: CallEnvSchema.optional(),
+    }).describe("🛂 Generate Verified Passport Object: Create immutable verified credentials after Guard validation passes."),
+]);
+// WIP Operations Schema
+const WipOperationsSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("generate"),
+        options: WipGenerationOptionsSchema.describe("WIP generation options"),
+        outputPath: z.string().describe("Output file path (.wip file). If file exists, it will be overwritten"),
+    }).describe("Generate WIP file from markdown text and optional images"),
+    z.object({
+        type: z.literal("verify"),
+        wipFilePath: z.string().describe("WIP file path to verify. Supports: 1) Local file path (e.g., '/path/to/file.wip', 'C:\\Users\\name\\doc.wip'), 2) Network URL (e.g., 'https://example.com/doc.wip', 'http://site.com/file.wip'), 3) Data URL (e.g., 'data:application/json;base64,eyJ3aXAiOi...')"),
+        hash_equal: z.string().optional().describe("Optional expected hash value. If provided, the function will first verify if the file's hash matches this value. If not matched, returns hash mismatch error."),
+    }).describe("Verify WIP file integrity and signatures"),
+    z.object({
+        type: z.literal("sign"),
+        wipFilePath: z.string().describe("WIP file path to sign. Supports: 1) Local file path (e.g., '/path/to/file.wip'), 2) Network URL (e.g., 'https://example.com/doc.wip'). The file will be loaded, validated, and signed"),
+        account: z.string().optional().describe("Signing account (account name or address). If not specified, uses default account"),
+        outputPath: z.string().optional().describe("Output file path. If not specified, adds 'signed_' prefix to original file name (e.g., 'doc.wip' becomes 'signed_doc.wip')"),
+    }).describe("Sign WIP file with account"),
+    z.object({
+        type: z.literal("wip2html"),
+        wipPath: z.string().describe("WIP file path or directory path. Supports: 1) Single WIP file (e.g., '/path/to/file.wip'), 2) Directory containing .wip files (e.g., '/path/to/wips/'), 3) Network URL (e.g., 'https://example.com/doc.wip'). When directory is provided, all .wip files in the directory will be converted to HTML"),
+        options: WipToHtmlOptionsSchema.optional().describe("Conversion options"),
+    }).describe("Convert WIP file to HTML format"),
+]);
+// Watch Query Operations Schema
+const WatchQueryOperationsSchema = z.discriminatedUnion("query_type", [
+    z.object({
+        query_type: z.literal("local_mark_list"),
+        filter: LocalMarkFilterSchema.optional().describe("Local mark filter"),
+    }).describe("Query local ID/USER address book with optional filter"),
+    z.object({
+        query_type: z.literal("account_list"),
+        filter: AccountFilterSchema.optional().describe("Account filter"),
+    }).describe("Query account list with optional filter"),
+    z.object({
+        query_type: z.literal("local_info_list"),
+        filter: LocalInfoFilterSchema.optional().describe("Local info filter"),
+    }).describe("Query local info list with optional filter"),
+    z.object({
+        query_type: z.literal("token_list"),
+        filter: TokenDataFilterSchema.optional(),
+    }).describe("Query token list with optional filter"),
+    z.object({
+        query_type: z.literal("account_balance"),
+        account: NameOrAddressSchema.optional().describe("Account name or address. Use empty string '' for the default account. Defaults to '' if omitted."),
+        token_type: TokenTypeSchema.optional().describe("Token type; default token type is 0x2::wow::WOW"),
+    }).describe("Query account balance or coin objects by the token type"),
+    z.object({
+        query_type: z.literal("onchain_personal_profile"),
+        account: NameOrAddressSchema.optional().describe("Account name or ID to query. Use empty string '' for the default account."),
+    }).describe("Query PUBLIC on-chain personal profile for any account address"),
+    z.object({
+        query_type: z.literal("onchain_objects"),
+        objects: z.array(NameOrAddressSchema).describe("List of object IDs to query"),
+    }).describe("Query on-chain objects"),
+    z.object({
+        query_type: z.literal("onchain_table"),
+        parent: NameOrAddressSchema,
+        object_type: ObjectTypeSchema,
+    }).describe("Query on-chain table data of the specified object"),
+    z.object({
+        query_type: z.literal("onchain_table_item_repository_data"),
+        parent: NameOrAddressSchema.describe("Parent object ID of the data table to query"),
+        name: z.string().describe("Name of the record to query"),
+        entity: z.union([AccountOrMark_AddressSchema, z.number()]).describe("ID or address of the entity; or address that number is casted to"),
+    }).describe("Query repository data table item"),
+    z.object({
+        query_type: z.literal("onchain_table_item_permission_perm"),
+        parent: NameOrAddressSchema.describe("Parent object ID of the data table to query"),
+        address: z.union([AccountOrMark_AddressSchema, z.string()]).describe("User ID or address, or Guard ID in the permission perm table"),
+    }).describe("Query permission perm table item"),
+    z.object({
+        query_type: z.literal("onchain_table_item_entity_registrar"),
+        address: z.union([AccountOrMark_AddressSchema, z.string()]).describe("User ID or address of the entity"),
+    }).describe("Query entity registrar table item"),
+    z.object({
+        query_type: z.literal("onchain_table_item_entity_linker"),
+        address: z.union([AccountOrMark_AddressSchema, z.string()]).describe("ID or address that the registrar votes are attached to"),
+    }).describe("Query entity linker table item"),
+    z.object({
+        query_type: z.literal("onchain_table_item_reward_record"),
+        parent: NameOrAddressSchema.describe("Parent object ID of the data table to query"),
+        address: AccountOrMark_AddressSchema.describe("User ID or address that claims the reward"),
+    }).describe("Query reward record table item"),
+    z.object({
+        query_type: z.literal("onchain_table_item_demand_presenter"),
+        parent: NameOrAddressSchema.describe("Parent object ID of the data table to query"),
+        address: AccountOrMark_AddressSchema.describe("User ID or address of the Demand presenter"),
+    }).describe("Query demand presenter table item"),
+    z.object({
+        query_type: z.literal("onchain_table_item_treasury_history"),
+        parent: NameOrAddressSchema.describe("Parent object ID of the data table to query"),
+        address: AccountOrMark_AddressSchema.describe("ID of the payment that the treasury record is attached to"),
+    }).describe("Query treasury record table item"),
+    z.object({
+        query_type: z.literal("onchain_table_item_machine_node"),
+        parent: NameOrAddressSchema.describe("Parent object ID of the data table to query"),
+        key: z.string().describe("String key of the node name to query"),
+    }).describe("Query machine node table item"),
+    z.object({
+        query_type: z.literal("onchain_table_item_progress_history"),
+        parent: NameOrAddressSchema.describe("Parent object ID of the data table to query"),
+        u64: z.union([z.number(), z.string()]).describe("U64 value of the record to query"),
+    }).describe("Query progress history table item"),
+    z.object({
+        query_type: z.literal("onchain_table_item_address_mark"),
+        parent: NameOrAddressSchema.describe("Parent object ID of the data table to query"),
+        address: AccountOrMark_AddressSchema.describe("ID or address that the mark name and tags are attached to"),
+    }).describe("Query address mark table item"),
+    z.object({
+        query_type: z.literal("onchain_received"),
+        object: z.string().describe("Object ID to query"),
+        all_type: z.boolean().optional().describe("Whether to query all types of received objects"),
+    }).describe("Query on-chain received balance, payments, and NFTs"),
+]);
+// ================================================
+// Handler Functions
+// ================================================
+async function handleOnchainOperations(args) {
+    console.log("=== handleOnchainOperations ===");
+    console.log("args:", JSON.stringify(args, null, 2));
+    try {
+        const validated = strictParse(OnchainOperationsSchema, args, "onchain_operations input");
+        console.log("validated:", JSON.stringify(validated, null, 2));
+        const env = getEnvConfig(validated.env);
+        switch (validated.operation_type) {
+            // Merchant Operations
+            case "service": {
+                const callService = new CallService(validated.data);
+                const result = validated.submission
+                    ? await callService.call_with_submission(env, transformSubmission(validated.submission))
+                    : await callService.call(env);
+                return handleCallResult(result);
+            }
+            case "machine": {
+                // Handle json_or_markdown_file if provided
+                if (validated.json_or_markdown_file !== undefined) {
+                    let fileContent;
+                    try {
+                        const filePath = resolve(validated.json_or_markdown_file);
+                        fileContent = readFileSync(filePath, 'utf-8');
+                    }
+                    catch (e) {
+                        throw new Error(`Failed to read file '${validated.json_or_markdown_file}': ${e.message}`);
+                    }
+                    const parseResult = parseMachineNodesFromText(fileContent);
+                    if (!parseResult.success) {
+                        const errorMessages = formatMachineNodeErrors(parseResult.errors);
+                        throw new Error(`Machine node validation failed for file '${validated.json_or_markdown_file}':\n\n${errorMessages}`);
+                    }
+                    if (!parseResult.data) {
+                        throw new Error(`No nodes found in file '${validated.json_or_markdown_file}'`);
+                    }
+                    // Set the parsed nodes in the data
+                    validated.data.node = {
+                        op: "set",
+                        nodes: parseResult.data,
+                        bReplace: true
+                    };
+                }
+                const callMachine = new CallMachine(validated.data);
+                const result = validated.submission
+                    ? await callMachine.call_with_submission(env, transformSubmission(validated.submission))
+                    : await callMachine.call(env);
+                return handleCallResult(result);
+            }
+            case "progress": {
+                const callProgress = new CallProgress(validated.data);
+                const result = validated.submission
+                    ? await callProgress.call_with_submission(env, transformSubmission(validated.submission))
+                    : await callProgress.call(env);
+                return handleCallResult(result);
+            }
+            case "repository": {
+                const callRepository = new CallRepository(validated.data);
+                const result = validated.submission
+                    ? await callRepository.call_with_submission(env, transformSubmission(validated.submission))
+                    : await callRepository.call(env);
+                return handleCallResult(result);
+            }
+            case "arbitration": {
+                const callArbitration = new CallArbitration(validated.data);
+                const result = validated.submission
+                    ? await callArbitration.call_with_submission(env, transformSubmission(validated.submission))
+                    : await callArbitration.call(env);
+                return handleCallResult(result);
+            }
+            case "contact": {
+                const callContact = new CallContact(validated.data);
+                const result = validated.submission
+                    ? await callContact.call_with_submission(env, transformSubmission(validated.submission))
+                    : await callContact.call(env);
+                return handleCallResult(result);
+            }
+            case "treasury": {
+                const callTreasury = new CallTreasury(validated.data);
+                const result = validated.submission
+                    ? await callTreasury.call_with_submission(env, transformSubmission(validated.submission))
+                    : await callTreasury.call(env);
+                return handleCallResult(result);
+            }
+            case "reward": {
+                const callReward = new CallReward(validated.data);
+                const result = validated.submission
+                    ? await callReward.call_with_submission(env, transformSubmission(validated.submission))
+                    : await callReward.call(env);
+                return handleCallResult(result);
+            }
+            case "allocation": {
+                const callAllocation = new CallAllocation(validated.data);
+                const result = validated.submission
+                    ? await callAllocation.call_with_submission(env, transformSubmission(validated.submission))
+                    : await callAllocation.call(env);
+                return handleCallResult(result);
+            }
+            case "permission": {
+                const callPermission = new CallPermission(validated.data);
+                const result = await callPermission.call(env);
+                return handleCallResult(result);
+            }
+            case "guard": {
+                const validatedData = validated.data;
+                // 处理 root.type === "file" 的情况：从文件加载 Guard 定义
+                if (validatedData.root?.type === "file") {
+                    const filePath = resolve(validatedData.root.file_path);
+                    let fileContent;
+                    try {
+                        fileContent = readFileSync(filePath, 'utf-8');
+                    }
+                    catch (e) {
+                        throw new Error(`Failed to read Guard definition file '${validatedData.root.file_path}': ${e.message}`);
+                    }
+                    // 使用 SDK 的 parseGuardFile 统一解析（支持 JSON 和 Markdown）
+                    const parseResult = parseGuardFile(fileContent, validatedData.root.format);
+                    if (!parseResult.success) {
+                        const errorMessages = formatGuardParseErrors(parseResult.errors);
+                        throw new Error(`Guard validation failed for file '${validatedData.root.file_path}':\n\n${errorMessages}`);
+                    }
+                    const fileData = parseResult.data;
+                    // 合并文件数据和用户提供的覆盖字段
+                    // 用户提供的字段优先级高于文件内容
+                    validatedData.root = { type: "node", node: fileData.root };
+                    if (fileData.table !== undefined && validatedData.table === undefined) {
+                        validatedData.table = fileData.table;
+                    }
+                    if (fileData.description !== undefined && validatedData.description === undefined) {
+                        validatedData.description = fileData.description;
+                    }
+                    if (fileData.rely !== undefined && validatedData.rely === undefined) {
+                        validatedData.rely = fileData.rely;
+                    }
+                    if (fileData.namedNew !== undefined && validatedData.namedNew === undefined) {
+                        validatedData.namedNew = fileData.namedNew;
+                    }
+                }
+                // 转换 root 格式：如果 root.type === "node"，提取 node 字段作为实际的 root
+                // 因为 SDK 期望直接的 GuardNode，而不是包装结构 { type: "node", node: GuardNode }
+                if (validatedData.root && typeof validatedData.root === 'object') {
+                    const rootObj = validatedData.root;
+                    if (rootObj.type === 'node' && rootObj.node) {
+                        validatedData.root = rootObj.node;
+                    }
+                }
+                // 验证必需的字段
+                if (!validatedData.table || validatedData.table.length === 0) {
+                    throw new Error("Guard 'table' field is required and cannot be empty");
+                }
+                if (!validatedData.root) {
+                    throw new Error("Guard 'root' field is required");
+                }
+                const callGuard = new CallGuard(validatedData);
+                const result = await callGuard.call(env);
+                return handleCallResult(result);
+            }
+            // Personal Operations
+            case "personal": {
+                const callPersonal = new CallPersonal(validated.data);
+                const result = await callPersonal.call(env);
+                return handleCallResult(result);
+            }
+            case "payment": {
+                const callPayment = new CallPayment(validated.data);
+                const result = await callPayment.call(env);
+                return handleCallResult(result);
+            }
+            case "demand": {
+                const callDemand = new CallDemand(validated.data);
+                const result = validated.submission
+                    ? await callDemand.call_with_submission(env, transformSubmission(validated.submission))
+                    : await callDemand.call(env);
+                return handleCallResult(result);
+            }
+            case "order": {
+                const callOrder = new CallOrder(validated.data);
+                const result = validated.submission
+                    ? await callOrder.call_with_submission(env, transformSubmission(validated.submission))
+                    : await callOrder.call(env);
+                return handleCallResult(result);
+            }
+            case "gen_passport": {
+                const result = await gen_passport(env, validated.guard, validated.info);
+                return handleCallResult(result);
+            }
+        }
+        throw new Error(`Unknown on-chain operation type: ${validated.operation_type}`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error: ${errorMessage}` }],
+            structuredContent: {
+                message: `Error: ${errorMessage}`,
+                result: {
+                    type: "error",
+                    error: errorMessage,
+                },
+            },
+        };
+    }
+}
+async function handleAccountOperation(args) {
+    try {
+        const validated = strictParse(AccountOperationSchema, args, "account_operation input");
+        const result = await account_operation(validated);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            structuredContent: {
+                result: {
+                    status: "success",
+                    data: result,
+                },
+            },
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error: ${errorMessage}` }],
+            structuredContent: {
+                result: {
+                    status: "error",
+                    error: errorMessage,
+                },
+            },
+        };
+    }
+}
+async function handleMarkOperation(args) {
+    try {
+        const validated = strictParse(LocalMarkOperationSchema, args, "local_mark_operation input");
+        const result = await local_mark_operation(validated);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            structuredContent: {
+                result: {
+                    status: "success",
+                    data: result,
+                },
+            },
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error: ${errorMessage}` }],
+            structuredContent: {
+                result: {
+                    status: "error",
+                    error: errorMessage,
+                },
+            },
+        };
+    }
+}
+async function handleInfoOperation(args) {
+    try {
+        const validated = strictParse(LocalInfoOperationSchema, args, "local_info_operation input");
+        const result = await local_info_operation(validated);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            structuredContent: {
+                result: {
+                    status: "success",
+                    data: result,
+                },
+            },
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error: ${errorMessage}` }],
+            structuredContent: {
+                result: {
+                    status: "error",
+                    error: errorMessage,
+                },
+            },
+        };
+    }
+}
+async function handleWipOperations(args) {
+    const validated = strictParse(WipOperationsSchema, args, "wip_file input");
+    let structuredContent;
+    switch (validated.type) {
+        case "generate": {
+            const result = await generate_wip(validated.options, validated.outputPath);
+            structuredContent = { result: { type: "generate", filePath: result } };
+            break;
+        }
+        case "verify": {
+            const result = await verify_wip(validated.wipFilePath, validated.hash_equal);
+            structuredContent = { result: { type: "verify", ...result } };
+            break;
+        }
+        case "sign": {
+            const result = await sign_wip(validated.wipFilePath, validated.account, validated.outputPath);
+            structuredContent = { result: { type: "sign", filePath: result } };
+            break;
+        }
+        case "wip2html": {
+            const result = await wip2html(validated.wipPath, validated.options);
+            let output = { type: "wip2html" };
+            if (typeof result === "string") {
+                output.html = result;
+            }
+            else if (Array.isArray(result)) {
+                output.files = result;
+            }
+            else {
+                output.html = String(result);
+            }
+            structuredContent = { result: output };
+            break;
+        }
+        default:
+            throw new Error("Unknown WIP operation type");
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify(structuredContent) }],
+        structuredContent,
+    };
+}
+async function handleWatchQueryOperations(args) {
+    const validated = strictParse(WatchQueryOperationsSchema, args, "watch_and_query input");
+    let result;
+    switch (validated.query_type) {
+        case "local_mark_list": {
+            const queryResult = await query_local_mark_list(validated.filter || {});
+            result = { query_type: "local_mark_list", result: queryResult };
+            break;
+        }
+        case "account_list": {
+            const queryResult = await query_account_list(validated.filter);
+            result = { query_type: "account_list", result: queryResult };
+            break;
+        }
+        case "local_info_list": {
+            const queryResult = await query_local_info_list(validated.filter);
+            result = { query_type: "local_info_list", result: queryResult };
+            break;
+        }
+        case "token_list": {
+            const queryResult = await query_local_token_list(validated.filter || {});
+            result = { query_type: "token_list", result: queryResult };
+            break;
+        }
+        case "account_balance": {
+            const queryResult = await query_account({ name_or_address: validated.account, token_type: validated.token_type, balance: true });
+            result = { query_type: "account_balance", result: queryResult };
+            break;
+        }
+        case "onchain_personal_profile": {
+            const queryResult = await query_personal({ account: validated.account });
+            result = { query_type: "onchain_personal_profile", result: queryResult };
+            break;
+        }
+        case "onchain_objects": {
+            const queryResult = await query_objects({ objects: validated.objects });
+            result = { query_type: "onchain_objects", result: queryResult };
+            break;
+        }
+        case "onchain_table": {
+            const queryResult = await query_table({ parent: validated.parent, object_type: validated.object_type });
+            result = { query_type: "onchain_table", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_repository_data": {
+            const queryResult = await queryTableItem_RepositoryData({ parent: validated.parent, name: validated.name, entity: validated.entity });
+            result = { query_type: "onchain_table_item_repository_data", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_permission_perm": {
+            const queryResult = await queryTableItem_PermissionPerm({ parent: validated.parent, address: validated.address });
+            result = { query_type: "onchain_table_item_permission_perm", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_reward_record": {
+            const queryResult = await queryTableItem_RewardRecord({ parent: validated.parent, address: validated.address });
+            result = { query_type: "onchain_table_item_reward_record", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_demand_presenter": {
+            const queryResult = await queryTableItem_DemandPresenter({ parent: validated.parent, address: validated.address });
+            result = { query_type: "onchain_table_item_demand_presenter", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_treasury_history": {
+            const queryResult = await queryTableItem_TreasuryHistory({ parent: validated.parent, address: validated.address });
+            result = { query_type: "onchain_table_item_treasury_history", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_machine_node": {
+            const queryResult = await queryTableItem_MachineNode({ parent: validated.parent, key: validated.key });
+            result = { query_type: "onchain_table_item_machine_node", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_progress_history": {
+            const queryResult = await queryTableItem_ProgressHistory({ parent: validated.parent, u64: validated.u64 });
+            result = { query_type: "onchain_table_item_progress_history", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_address_mark": {
+            const queryResult = await queryTableItem_AddressMark({ parent: validated.parent, address: validated.address });
+            result = { query_type: "onchain_table_item_address_mark", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_entity_registrar": {
+            const queryResult = await queryTableItem_EntityRegistrar({ address: validated.address });
+            result = { query_type: "onchain_table_item_entity_registrar", result: queryResult };
+            break;
+        }
+        case "onchain_table_item_entity_linker": {
+            const queryResult = await queryTableItem_EntityLinker({ address: validated.address });
+            result = { query_type: "onchain_table_item_entity_linker", result: queryResult };
+            break;
+        }
+        case "onchain_received": {
+            const queryResult = await query_received({ object: validated.object, all_type: validated.all_type });
+            result = { query_type: "onchain_received", result: queryResult };
+            break;
+        }
+        default:
+            throw new Error(`Unknown watch query type. Valid query_types are: "local_mark_list", "account_list", "local_info_list", "token_list", "account_balance", "onchain_personal_profile", "onchain_objects", "onchain_table", "onchain_table_item_repository_data", "onchain_table_item_permission_perm", "onchain_table_item_reward_record", "onchain_table_item_demand_presenter", "onchain_table_item_treasury_history", "onchain_table_item_machine_node", "onchain_table_item_progress_history", "onchain_table_item_address_mark", "onchain_table_item_entity_registrar", "onchain_table_item_entity_linker", "onchain_received"`);
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result }) }],
+        structuredContent: { result },
+    };
+}
+async function handleWowokInfo(args) {
+    const validated = strictParse(ProtocolInfoQuerySchema, args, "wowok_buildin_info input");
+    const queryResult = await queryProtocolInfo(validated);
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result: queryResult }) }],
+        structuredContent: { result: queryResult },
+    };
+}
+async function handleOnchainEvents(args) {
+    const validated = strictParse(OnchainEventsInputSchema, args, "onchain_events input");
+    const queryResult = await query_events({
+        type: validated.type,
+        cursor: validated.cursor ?? null,
+        limit: validated.limit ?? null,
+        order: validated.order ?? null,
+        no_cache: validated.no_cache,
+        network: validated.network,
+    });
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result: queryResult }) }],
+        structuredContent: { result: queryResult },
+    };
+}
+async function handleMessengerOperation(args) {
+    const validated = strictParse(MessengerOperationInputSchema, args, "messenger_operation input");
+    let result;
+    switch (validated.operation) {
+        case "watch_conversations": {
+            const conversations = await watch_conversations(validated.account);
+            result = { operation: "watch_conversations", result: conversations };
+            break;
+        }
+        case "send_message": {
+            const sendResult = await send_message(validated.from, validated.to, validated.content, validated.options);
+            result = { operation: "send_message", result: sendResult };
+            break;
+        }
+        case "send_file": {
+            const sendResult = await send_file(validated.from, validated.to, validated.filePath, validated.options);
+            result = { operation: "send_file", result: sendResult };
+            break;
+        }
+        case "watch_messages": {
+            const messages = await watch_messages(validated.filter);
+            result = { operation: "watch_messages", result: messages };
+            break;
+        }
+        case "extract_zip_messages": {
+            const extractedPaths = await extract_zip_messages(validated.account, validated.messages, validated.outputDir);
+            result = { operation: "extract_zip_messages", result: extractedPaths };
+            break;
+        }
+        case "generate_wts": {
+            const wtsResult = await generate_wts(validated.params);
+            result = { operation: "generate_wts", result: wtsResult };
+            break;
+        }
+        case "verify_wts": {
+            const verifyResult = await verify_wts(validated.wtsFilePath);
+            result = { operation: "verify_wts", result: verifyResult };
+            break;
+        }
+        case "sign_wts": {
+            const signedPath = await sign_wts(validated.wtsFilePath, validated.account, validated.outputPath);
+            result = { operation: "sign_wts", result: signedPath };
+            break;
+        }
+        case "wts2html": {
+            const htmlResult = await wts2html(validated.wtsPath, validated.options);
+            result = { operation: "wts2html", result: htmlResult };
+            break;
+        }
+        case "proof_message": {
+            const proofResult = await proof_message(validated.account, validated.messageId, validated.network);
+            result = { operation: "proof_message", result: proofResult };
+            break;
+        }
+        case "blacklist": {
+            // TODO: Uncomment once blacklist is properly imported
+            // const blacklistResult = await blacklist({
+            //     account: validated.account,
+            //     ...validated.blacklist
+            // } as any);
+            // result = { operation: "blacklist", op: validated.blacklist.op, result: blacklistResult.result };
+            throw new Error("Blacklist operation is temporarily unavailable. Please re-install agent/mcp dependencies.");
+            break;
+        }
+        case "friendslist": {
+            // TODO: Uncomment once friendslist is properly imported
+            // const friendslistResult = await friendslist({
+            //     account: validated.account,
+            //     ...validated.friendslist
+            // } as any);
+            // result = { operation: "friendslist", op: validated.friendslist.op, result: friendslistResult.result };
+            throw new Error("Friendslist operation is temporarily unavailable. Please re-install agent/mcp dependencies.");
+            break;
+        }
+        case "guardlist": {
+            // TODO: Uncomment once guardlist is properly imported
+            // const guardlistResult = await guardlist({
+            //     account: validated.account,
+            //     ...validated.guardlist
+            // } as any);
+            // result = { operation: "guardlist", op: validated.guardlist.op, result: guardlistResult.result };
+            throw new Error("Guardlist operation is temporarily unavailable. Please re-install agent/mcp dependencies.");
+            break;
+        }
+        default:
+            throw new Error(`Unknown messenger operation: ${validated.operation}`);
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        structuredContent: result,
+    };
+}
+// ================================================
+// Guard2File Tool Handler
+// ================================================
+async function handleGuard2File(args) {
+    const validated = strictParse(Guard2File_InputSchema, args, "guard2file input");
+    const env = getEnvConfig(validated.env);
+    try {
+        // Call guard2file function from SDK
+        await guard2file(validated.guard, validated.file_path, validated.format || "json", env.network);
+        // Return success result
+        const result = {
+            result: {
+                status: "success",
+                data: {
+                    file_path: resolve(validated.file_path),
+                    format: validated.format || "json",
+                    guard_object: validated.guard,
+                },
+            },
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        // Return error result
+        const result = {
+            result: {
+                status: "error",
+                error: error.message,
+            },
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            structuredContent: result,
+        };
+    }
+}
+// ================================================
+// MachineNode2File Tool Handler
+// ================================================
+async function handleMachineNode2File(args) {
+    const validated = strictParse(MachineNode2File_InputSchema, args, "machineNode2file input");
+    const env = getEnvConfig(validated.env);
+    try {
+        // Call machineNode2file function from SDK
+        await machineNode2file(validated.machine, validated.file_path, validated.format || "json", env.network);
+        // Return success result
+        const result = {
+            result: {
+                status: "success",
+                data: {
+                    file_path: resolve(validated.file_path),
+                    format: validated.format || "json",
+                    machine_object: validated.machine,
+                    node_count: 0, // SDK function doesn't return node count, but we can add it later
+                },
+            },
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        // Return error result
+        const result = {
+            result: {
+                status: "error",
+                error: error.message,
+            },
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            structuredContent: result,
+        };
+    }
+}
+// ================================================
+// Schema Query Tool Handler
+// ================================================
+// Export Schema Definitions for Tool Schema Query
+// ================================================
+export { OnchainOperationsSchema, WipOperationsSchema, WatchQueryOperationsSchema, AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, ProtocolInfoQuerySchema, CallOutputSchema, MessengerOperationInputSchema, MessengerOperationOutputSchema };
+// ================================================
+// Main Function - Register All Tools
+// ================================================
+async function main() {
+    // Unified On-chain Operations Tool (Merged from Merchant and Personal Operations)
+    server.registerTool("onchain_operations", {
+        title: "⛓️ On-chain Operations",
+        description: "On-chain operations for WoWok object: service (marketplace listings), machine (workflow templates), progress (order tracking), repository (on-chain database), arbitration (dispute resolution), contact (IM management), treasury (team funds), reward (incentive pools), allocation (auto-distribution), permission (access control), guard (programmable trust rules), personal (public profile), payment (direct coin transfers), demand (service requests), order (order management), gen_passport (verified credentials).",
+        inputSchema: OnchainOperationsSchema,
+        outputSchema: CallOutputSchema,
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+        _meta: createToolMeta("operation", ["service", "machine", "progress", "repository", "arbitration", "contact", "treasury", "reward", "allocation", "permission", "guard", "personal", "payment", "demand", "order", "gen_passport", "on-chain", "blockchain"]),
+    }, handleOnchainOperations);
+    // Account Operation Tool (Local)
+    server.registerTool("account_operation", {
+        title: "🔒 LOCAL ONLY: Account - Wallet Management",
+        description: "🔒 100% LOCAL, NEVER ON-CHAIN 🔒 Manage WoWok accounts locally on device: generate, suspend, resume, faucet-test, operate assets, sign data, etc.",
+        inputSchema: AccountOperationSchema,
+        outputSchema: AccountOperationOutputWrappedSchema,
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+        _meta: createToolMeta("operation", ["account", "local", "private", "wallet", "off-chain"]),
+    }, handleAccountOperation);
+    // Local Mark Operation Tool
+    server.registerTool("local_mark_operation", {
+        title: "🔒 LOCAL ONLY: LocalMark - Address Book Management",
+        description: "100% LOCAL, NEVER ON-CHAIN 🔒 Manage ID names and tags stored ONLY on your local device for easy identification of user address or object IDs by name.",
+        inputSchema: LocalMarkOperationSchema,
+        outputSchema: LocalMarkOperationOutputWrappedSchema,
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+        _meta: createToolMeta("operation", ["mark", "local", "private", "address-book", "off-chain"]),
+    }, handleMarkOperation);
+    // Local Info Operation Tool
+    server.registerTool("local_info_operation", {
+        title: "🔒 LOCAL ONLY: LocalInfo - Private Data Management",
+        description: "100% LOCAL, NEVER ON-CHAIN 🔒 Manage sensitive personal information stored ONLY on your device: delivery addresses, phone numbers, contacts.",
+        inputSchema: LocalInfoOperationSchema,
+        outputSchema: LocalInfoOperationOutputWrappedSchema,
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+        _meta: createToolMeta("operation", ["info", "local", "private", "data-management", "off-chain"]),
+    }, handleInfoOperation);
+    // WIP File Operations Tool
+    server.registerTool("wip_file", {
+        title: "🤝 Witness Information Promise File Operations",
+        description: "generate (create WIP files from markdown and images), verify (integrity check), sign (add signatures), or wip2html (convert to HTML).",
+        inputSchema: WipOperationsSchema,
+        outputSchema: z.object({
+            result: WipOperationOutputSchema,
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+        _meta: createToolMeta("operation", ["wip", "promise", "file-generation", "verification", "signature", "local"]),
+    }, handleWipOperations);
+    // Messenger Operations Tool
+    server.registerTool("messenger_operation", {
+        title: "💬 Messenger Operations",
+        description: "WoWok encrypted messenger operations: watch conversations, send message, send file, watch messages, extract zip messages, generate WTS, verify WTS, sign WTS, WTS to HTML, proof message on-chain, manage blacklist, friendslist, and guardlist.",
+        inputSchema: MessengerOperationInputSchema,
+        outputSchema: MessengerOperationOutputSchema,
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+        _meta: createToolMeta("operation", ["messenger", "message", "file", "wts", "blacklist", "friendslist", "guardlist", "proof", "communication"]),
+    }, handleMessengerOperation);
+    // Guard2File Tool - Export Guard to JSON/Markdown file
+    server.registerTool("guard2file", {
+        title: "📄 Guard to File - Export Guard Definition",
+        description: "Export a Guard object's definition from the blockchain to a local JSON or Markdown file for editing and creating new Guard objects. Note: To query on-chain object information, use the 'query_toolkit' tool instead.",
+        inputSchema: Guard2File_InputSchema,
+        outputSchema: Guard2File_OutputWrappedSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        _meta: createToolMeta("generate file", ["guard", "export", "file", "json", "markdown", "on-chain"]),
+    }, handleGuard2File);
+    // MachineNode2File Tool - Export Machine nodes to JSON/Markdown file
+    server.registerTool("machineNode2file", {
+        title: "⚙️ Machine Node to File - Export Machine Node Definition",
+        description: "Export a Machine object's node definition from the blockchain to a local JSON or Markdown file for editing and creating new Machine objects. Note: To query on-chain object information, use the 'query_toolkit' tool instead.",
+        inputSchema: MachineNode2File_InputSchema,
+        outputSchema: MachineNode2File_OutputWrappedSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        _meta: createToolMeta("generate file", ["machine", "export", "file", "json", "markdown", "on-chain", "workflow"]),
+    }, handleMachineNode2File);
+    server.registerTool("query_toolkit", {
+        title: "🔍 Data Query Toolkit",
+        description: "WOWOK data query toolkit: Query local naming info (accounts, names, Object IDs), and query on-chain WOWOK objects, table items, events, received tokens, user profile, etc.",
+        inputSchema: WatchQueryOperationsSchema,
+        outputSchema: WatchQueryOperationsResultSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        _meta: createToolMeta("query", ["watch", "query", "on-chain", "local", "events", "objects", "tables", "tokens", "balance", "profile"]),
+    }, handleWatchQueryOperations);
+    server.registerTool("onchain_events", {
+        title: "📅 Watch On-chain Events",
+        description: "Watch on-chain WOWOK events by type. Supports arbitration events, new order events, progress events, demand presentation events, demand feedback events, and new entity registration events. Use pagination cursor for fetching large result sets.",
+        inputSchema: OnchainEventsInputSchema,
+        outputSchema: OnchainEventsResultSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        _meta: createToolMeta("watch events", ["events", "on-chain", "arbitration", "order", "progress", "demand", "entity"]),
+    }, handleOnchainEvents);
+    server.registerTool("wowok_buildin_info", {
+        title: "ℹ️ WoWok Build-in Information",
+        description: "Query WoWok protocol information: 'constants', 'built-in permissions', 'guard instructions', 'current network', or 'value types'.",
+        inputSchema: ProtocolInfoQuerySchema,
+        outputSchema: ProtocolInfoResultSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        _meta: createToolMeta("WoWok info", ["build-in", "constants", "permissions", "guard", "network", "value-types"]),
+    }, handleWowokInfo);
+    // Documents and Learn Tool - Provide documentation URL for users and AI
+    server.registerTool("documents_and_learn", {
+        title: "📚 Documents and Learn",
+        description: "Access WoWok documentation and learning resources. Provides official documentation URL for users and AI to get more information about WoWok protocol, components, and usage.",
+        inputSchema: z.object({
+            topic: z.string().optional().describe("Optional topic to search for in documentation (e.g., 'guard', 'service', 'messenger', 'stage-01-introduction')"),
+        }),
+        outputSchema: z.object({
+            documentation_url: z.string().describe("Official WoWok documentation URL on GitHub"),
+            topic: z.string().optional().describe("Requested topic if specified"),
+            message: z.string().describe("Welcome message with documentation information"),
+        }),
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        _meta: createToolMeta("documentation", ["docs", "learn", "tutorial", "guide", "help", "reference"]),
+    }, async (args) => {
+        const GITHUB_BASE_URL = "https://github.com/wowok-ai/docs/blob/main/docs";
+        if (!args.topic) {
+            // No topic specified, return base documentation URL
+            const url = GITHUB_BASE_URL;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Welcome to WoWok Documentation! Access comprehensive guides, tutorials, and API references at: ${url}`,
+                    },
+                ],
+                structuredContent: {
+                    documentation_url: url,
+                },
+            };
+        }
+        // Topic specified, construct URL
+        const url = `${GITHUB_BASE_URL}/${args.topic}.md`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Documentation for "${args.topic}"\nGitHub URL: ${url}`,
+                },
+            ],
+            structuredContent: {
+                documentation_url: url,
+                topic: args.topic,
+            },
+        };
+    });
+    // Connect to transport
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Cleanup on exit
+    process.on("SIGINT", async () => {
+        await server.close();
+        process.exit(0);
+    });
+}
+main().catch(console.error);