@agent-deck/backend 1.2.10 → 1.3.0

package/dist/mcp-server.js

@@ -10,9 +10,10 @@ const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const shared_1 = require("@agent-deck/shared");
 const express_1 = __importDefault(require("express"));
 const node_crypto_1 = require("node:crypto");
-const zod_1 = require("zod");
 const version_1 = require("./lib/version");
 const mcp_session_binding_1 = require("./mcp-session-binding");
+const register_1 = require("./mcp-tools/register");
+const profile_1 = require("./mcp-tools/profile");
 const agentClientHeaders = {
     [shared_1.AGENT_DECK_CLIENT_HEADER]: shared_1.AGENT_DECK_AGENT_CLIENT,
     Accept: 'application/json',
@@ -21,6 +22,7 @@ class AgentDeckMCPServer {
     port;
     app;
     backendUrl;
+    toolProfile;
     sessions = new Map();
     /** Set only while registerTools/registerResources run for a new session server. */
     mcpServerForRegistration;
@@ -36,9 +38,10 @@ class AgentDeckMCPServer {
         }
         return this.mcpServerForRegistration;
     }
-    constructor(port = 3001, backendUrl = 'http://localhost:8000') {
+    constructor(port = 3001, backendUrl = 'http://localhost:8000', toolProfile) {
         this.port = port;
         this.backendUrl = backendUrl;
+        this.toolProfile = toolProfile ?? (0, profile_1.resolveMcpToolProfile)();
         this.app = (0, express_1.default)();
         this.app.use(express_1.default.json());
         this.setupRoutes();
@@ -206,647 +209,21 @@ class AgentDeckMCPServer {
         this.server.registerTool(name, config, handler);
     }
     setupTools() {
-        this.registerTool("bind_workspace", {
-            title: "Bind Workspace",
-            description: "Bind this MCP session to a workspace root and deck. Use get_decks to list deck ids.",
-            inputSchema: {
-                workspaceRoot: zod_1.z.string(),
-                deckId: zod_1.z.string().uuid(),
-            },
-        }, async ({ workspaceRoot, deckId }) => {
-            try {
-                const sessionId = this.getSessionId();
-                this.sessionBinding.setWorkspace(sessionId, workspaceRoot);
-                const deck = await this.fetchDeck(deckId);
-                this.sessionBinding.setDeckId(sessionId, deckId);
-                await this.registerLiveDisplay(sessionId);
-                const payload = await this.buildBindingPayload(sessionId);
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                ...payload,
-                                deck_name: deck.name,
-                                message: 'Session bound to deck.',
-                            }, null, 2),
-                        }],
-                };
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("switch_bound_deck", {
-            title: "Switch Bound Deck",
-            description: "Switch the deck for this MCP session only. Use when multiple agent sessions share the same workspace path.",
-            inputSchema: { deckId: zod_1.z.string().uuid() },
-        }, async ({ deckId }) => {
-            try {
-                const sessionId = this.getSessionId();
-                const deck = await this.fetchDeck(deckId);
-                this.sessionBinding.setDeckId(sessionId, deckId);
-                await this.registerLiveDisplay(sessionId);
-                const payload = await this.buildBindingPayload(sessionId);
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                ...payload,
-                                deck_name: deck.name,
-                                message: 'Session deck switched. Other sessions are unchanged.',
-                            }, null, 2),
-                        }],
-                };
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("get_session_binding", {
-            title: "Get Session Binding",
-            description: "Show workspace and effective deck for this MCP session (session override or env default).",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const sessionId = this.getSessionId();
-                const snapshot = this.sessionBinding.getBinding(sessionId);
-                const deck = await this.callBackendAPI('/api/scope/deck');
-                const badge = this.badgeBySession.get(sessionId);
-                const cardCounts = deck ? (0, shared_1.countDeckCards)(deck) : { mcp: 0, credentials: 0, playbooks: 0 };
-                const displaySummary = (0, shared_1.formatDisplayLine)(deck?.name ?? null, cardCounts, { badge });
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                workspaceRoot: snapshot.workspaceRoot,
-                                session_deck_id: snapshot.deckId,
-                                session_deck_source: snapshot.deckSource,
-                                effective_deck_id: deck?.id,
-                                effective_deck_name: deck?.name,
-                                effective_deck_source: (0, mcp_session_binding_1.resolveDeckBindingSource)(snapshot),
-                                badge,
-                                display_summary: displaySummary,
-                            }, null, 2),
-                        }],
-                };
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        // Get all decks (metadata only; credentials stripped unless bound)
-        this.registerTool("get_decks", {
-            title: "Get Decks",
-            description: "Get all available decks from Agent Deck",
-            inputSchema: {}
-        }, async () => {
-            try {
-                const decks = await this.callBackendAPI('/api/decks');
-                return {
-                    content: [{ type: "text", text: JSON.stringify(decks, null, 2) }]
-                };
-            }
-            catch (error) {
-                return {
-                    content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }]
-                };
-            }
-        });
-        this.registerTool("get_bound_deck", {
-            title: "Get Bound Deck",
-            description: "Get the deck bound to this session (session deckId or env AGENT_DECK_DECK_ID)",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const deck = await this.callBackendAPI('/api/scope/deck');
-                return {
-                    content: [{ type: "text", text: JSON.stringify(deck, null, 2) }],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }],
-                };
-            }
-        });
-        // Deprecated alias
-        this.registerTool("get_active_deck", {
-            title: "Get Active Deck (deprecated)",
-            description: "Deprecated — use get_bound_deck. Returns the workspace-bound deck.",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const deck = await this.callBackendAPI('/api/scope/deck');
-                return {
-                    content: [{ type: "text", text: JSON.stringify(deck, null, 2) }],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }],
-                };
-            }
-        });
-        this.registerTool("list_bound_deck_services", {
-            title: "List Bound Deck Services",
-            description: "List MCP services on the workspace-bound deck",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const deck = await this.callBackendAPI('/api/scope/deck');
-                const services = deck?.services ?? [];
-                return { content: [{ type: "text", text: JSON.stringify(services, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
-        });
-        this.registerTool("list_active_deck_services", {
-            title: "List Active Deck Services (deprecated)",
-            description: "Deprecated — use list_bound_deck_services",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const deck = await this.callBackendAPI('/api/scope/deck');
-                const services = deck?.services ?? [];
-                return { content: [{ type: "text", text: JSON.stringify(services, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
-        });
-        this.registerTool("list_bound_deck_credentials", {
-            title: "List Bound Deck Credentials",
-            description: "List API key metadata on the workspace-bound deck",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const credentials = await this.callBackendAPI('/api/credentials');
-                return { content: [{ type: "text", text: JSON.stringify(credentials, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
-        });
-        this.registerTool("list_active_deck_credentials", {
-            title: "List Active Deck Credentials (deprecated)",
-            description: "Deprecated — use list_bound_deck_credentials",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const credentials = await this.callBackendAPI('/api/credentials');
-                return { content: [{ type: "text", text: JSON.stringify(credentials, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
-        });
-        this.registerTool("list_playbooks", {
-            title: "List Playbooks",
-            description: "List playbook cards on the bound deck (id, title, triggers)",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const playbooks = await this.callBackendAPI('/api/playbooks/summaries');
-                return { content: [{ type: "text", text: JSON.stringify(playbooks, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
-        });
-        this.registerTool("get_playbook", {
-            title: "Get Playbook",
-            description: "Get full markdown body, metadata, and dependencies for a playbook card by id",
-            inputSchema: { playbook_id: zod_1.z.string() },
-        }, async ({ playbook_id }) => {
-            try {
-                const playbook = await this.callBackendAPI(`/api/playbooks/${encodeURIComponent(playbook_id)}`);
-                return { content: [{ type: "text", text: JSON.stringify(playbook, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
-        });
-        this.registerTool("register_playbook", {
-            title: "Register Playbook",
-            description: "Create a playbook card, auto-detect API key and MCP dependencies from the content, and add it to the bound deck by default",
-            inputSchema: {
-                title: zod_1.z.string(),
-                body: zod_1.z.string(),
-                triggers: zod_1.z.array(zod_1.z.string()).optional(),
-                playbook_id: zod_1.z.string().optional(),
-                exec: zod_1.z.string().optional(),
-                skill: zod_1.z.string().optional(),
-                depends_on_credential_ids: zod_1.z.array(zod_1.z.string()).optional(),
-                depends_on_service_ids: zod_1.z.array(zod_1.z.string()).optional(),
-                add_to_bound_deck: zod_1.z.boolean().optional(),
-                auto_detect_dependencies: zod_1.z.boolean().optional(),
-            },
-        }, async (args) => {
-            try {
-                const playbook = await this.callBackendAPI("/api/playbooks", {
-                    method: "POST",
-                    headers: { "Content-Type": "application/json" },
-                    body: JSON.stringify({
-                        title: args.title,
-                        body: args.body,
-                        triggers: args.triggers,
-                        id: args.playbook_id,
-                        exec: args.exec,
-                        skill: args.skill,
-                        dependsOnCredentialIds: args.depends_on_credential_ids,
-                        dependsOnServiceIds: args.depends_on_service_ids,
-                        addToBoundDeck: args.add_to_bound_deck,
-                        autoDetectDependencies: args.auto_detect_dependencies,
-                    }),
-                });
-                return { content: [{ type: "text", text: JSON.stringify(playbook, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
-        });
-        this.registerTool("update_playbook", {
-            title: "Update Playbook",
-            description: "Update a playbook on the bound deck. Dependencies are re-detected from the updated content by default.",
-            inputSchema: {
-                playbook_id: zod_1.z.string(),
-                title: zod_1.z.string().optional(),
-                body: zod_1.z.string().optional(),
-                triggers: zod_1.z.array(zod_1.z.string()).optional(),
-                exec: zod_1.z.string().optional(),
-                skill: zod_1.z.string().optional(),
-                depends_on_credential_ids: zod_1.z.array(zod_1.z.string()).optional(),
-                depends_on_service_ids: zod_1.z.array(zod_1.z.string()).optional(),
-                auto_detect_dependencies: zod_1.z.boolean().optional(),
-            },
-        }, async ({ playbook_id, ...args }) => {
-            try {
-                const playbook = await this.callBackendAPI(`/api/playbooks/${encodeURIComponent(playbook_id)}`, {
-                    method: "PUT",
-                    headers: { "Content-Type": "application/json" },
-                    body: JSON.stringify({
-                        title: args.title,
-                        body: args.body,
-                        triggers: args.triggers,
-                        exec: args.exec,
-                        skill: args.skill,
-                        dependsOnCredentialIds: args.depends_on_credential_ids,
-                        dependsOnServiceIds: args.depends_on_service_ids,
-                        autoDetectDependencies: args.auto_detect_dependencies,
-                    }),
-                });
-                return { content: [{ type: "text", text: JSON.stringify(playbook, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
-        });
-        this.registerTool("list_collection_services", {
-            title: "List Collection Services",
-            description: "List all registered MCP services in the collection (metadata only)",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const services = await this.callBackendAPI('/api/services');
-                return this.toolResult(services);
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("register_service", {
-            title: "Register Service",
-            description: "Register an MCP service in the collection. Optionally add it to the bound deck. OAuth setup still requires the dashboard browser flow.",
-            inputSchema: {
-                name: zod_1.z.string(),
-                type: zod_1.z.enum(['mcp', 'a2a', 'local-mcp']),
-                url: zod_1.z.string(),
-                description: zod_1.z.string().optional(),
-                cardColor: zod_1.z.string().optional(),
-                credentialId: zod_1.z.string().optional(),
-                headers: zod_1.z.record(zod_1.z.string()).optional(),
-                localCommand: zod_1.z.string().optional(),
-                localArgs: zod_1.z.array(zod_1.z.string()).optional(),
-                localWorkingDir: zod_1.z.string().optional(),
-                localEnv: zod_1.z.record(zod_1.z.string()).optional(),
-                add_to_bound_deck: zod_1.z.boolean().optional(),
-                position: zod_1.z.number().optional(),
-            },
-        }, async (args) => {
-            try {
-                const { add_to_bound_deck, position, ...serviceInput } = args;
-                const service = await this.callBackendAPI('/api/services', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(serviceInput),
-                });
-                if (add_to_bound_deck !== false) {
-                    const deckId = await this.getBoundDeckId();
-                    await this.callBackendAPI(`/api/decks/${deckId}/services`, {
-                        method: 'POST',
-                        headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify({ serviceId: service.id, position }),
-                    });
-                }
-                return this.toolResult(service);
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("update_service", {
-            title: "Update Service",
-            description: "Update MCP service metadata in the collection (not OAuth tokens — use dashboard for OAuth)",
-            inputSchema: {
-                service_id: zod_1.z.string(),
-                name: zod_1.z.string().optional(),
-                type: zod_1.z.enum(['mcp', 'a2a', 'local-mcp']).optional(),
-                url: zod_1.z.string().optional(),
-                description: zod_1.z.string().optional(),
-                cardColor: zod_1.z.string().optional(),
-                credentialId: zod_1.z.string().optional(),
-                headers: zod_1.z.record(zod_1.z.string()).optional(),
-                localCommand: zod_1.z.string().optional(),
-                localArgs: zod_1.z.array(zod_1.z.string()).optional(),
-                localWorkingDir: zod_1.z.string().optional(),
-                localEnv: zod_1.z.record(zod_1.z.string()).optional(),
-            },
-        }, async ({ service_id, ...updates }) => {
-            try {
-                const service = await this.callBackendAPI(`/api/services/${service_id}`, {
-                    method: 'PUT',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(updates),
-                });
-                return this.toolResult(service);
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("delete_service", {
-            title: "Delete Service",
-            description: "Remove an MCP service from the collection entirely",
-            inputSchema: { service_id: zod_1.z.string() },
-        }, async ({ service_id }) => {
-            try {
-                await this.callBackendAPI(`/api/services/${service_id}`, { method: 'DELETE' });
-                return this.toolResult({ success: true, service_id });
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("add_service_to_bound_deck", {
-            title: "Add Service To Bound Deck",
-            description: "Link an existing MCP service from the collection onto the bound deck",
-            inputSchema: {
-                service_id: zod_1.z.string(),
-                position: zod_1.z.number().optional(),
-            },
-        }, async ({ service_id, position }) => {
-            try {
-                const deckId = await this.getBoundDeckId();
-                await this.callBackendAPI(`/api/decks/${deckId}/services`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ serviceId: service_id, position }),
-                });
-                return this.toolResult({ success: true, deck_id: deckId, service_id });
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("remove_service_from_bound_deck", {
-            title: "Remove Service From Bound Deck",
-            description: "Unlink an MCP service from the bound deck (service stays in the collection)",
-            inputSchema: { service_id: zod_1.z.string() },
-        }, async ({ service_id }) => {
-            try {
-                const deckId = await this.getBoundDeckId();
-                await this.callBackendAPI(`/api/decks/${deckId}/services`, {
-                    method: 'DELETE',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ serviceId: service_id }),
-                });
-                return this.toolResult({ success: true, deck_id: deckId, service_id });
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("update_service_tool_settings", {
-            title: "Update Service Tool Settings",
-            description: "Enable or disable individual tools for an MCP service on the bound deck",
-            inputSchema: {
-                service_id: zod_1.z.string(),
-                disabled_tools: zod_1.z.array(zod_1.z.string()),
-            },
-        }, async ({ service_id, disabled_tools }) => {
-            try {
-                const service = await this.callBackendAPI(`/api/services/${service_id}/tool-settings`, {
-                    method: 'PUT',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ disabledTools: disabled_tools }),
-                });
-                return this.toolResult(service);
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("list_collection_credentials", {
-            title: "List Collection Credentials",
-            description: "List all API key metadata in the collection (no secret values). Use credential ids to link keys to the bound deck after the user stores the secret in the dashboard.",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const credentials = await this.callBackendAPI('/api/credentials/collection');
-                return this.toolResult(credentials);
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("add_credential_to_bound_deck", {
-            title: "Add Credential To Bound Deck",
-            description: "Link an existing API key (by credential id) to the bound deck. The secret must already be stored via the dashboard or CLI.",
-            inputSchema: {
-                credential_id: zod_1.z.string(),
-                position: zod_1.z.number().optional(),
-            },
-        }, async ({ credential_id, position }) => {
-            try {
-                const deckId = await this.getBoundDeckId();
-                await this.callBackendAPI(`/api/decks/${deckId}/credentials`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ credentialId: credential_id, position }),
-                });
-                return this.toolResult({ success: true, deck_id: deckId, credential_id });
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("remove_credential_from_bound_deck", {
-            title: "Remove Credential From Bound Deck",
-            description: "Unlink an API key from the bound deck (credential stays in the vault)",
-            inputSchema: { credential_id: zod_1.z.string() },
-        }, async ({ credential_id }) => {
-            try {
-                const deckId = await this.getBoundDeckId();
-                await this.callBackendAPI(`/api/decks/${deckId}/credentials`, {
-                    method: 'DELETE',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ credentialId: credential_id }),
-                });
-                return this.toolResult({ success: true, deck_id: deckId, credential_id });
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("list_collection_playbooks", {
-            title: "List Collection Playbooks",
-            description: "List all playbook cards in the collection (for linking existing playbooks to the bound deck)",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const playbooks = await this.callBackendAPI('/api/playbooks/collection');
-                return this.toolResult(playbooks);
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("add_playbook_to_bound_deck", {
-            title: "Add Playbook To Bound Deck",
-            description: "Link an existing playbook card from the collection onto the bound deck",
-            inputSchema: {
-                playbook_id: zod_1.z.string(),
-                position: zod_1.z.number().optional(),
-            },
-        }, async ({ playbook_id, position }) => {
-            try {
-                const deckId = await this.getBoundDeckId();
-                await this.callBackendAPI(`/api/decks/${deckId}/playbooks`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ playbookId: playbook_id, position }),
-                });
-                return this.toolResult({ success: true, deck_id: deckId, playbook_id });
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("remove_playbook_from_bound_deck", {
-            title: "Remove Playbook From Bound Deck",
-            description: "Unlink a playbook from the bound deck (playbook stays in the collection)",
-            inputSchema: { playbook_id: zod_1.z.string() },
-        }, async ({ playbook_id }) => {
-            try {
-                const deckId = await this.getBoundDeckId();
-                await this.callBackendAPI(`/api/decks/${deckId}/playbooks`, {
-                    method: 'DELETE',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ playbookId: playbook_id }),
-                });
-                return this.toolResult({ success: true, deck_id: deckId, playbook_id });
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("delete_playbook", {
-            title: "Delete Playbook",
-            description: "Delete a playbook from the collection (must be on the bound deck for agent clients)",
-            inputSchema: { playbook_id: zod_1.z.string() },
-        }, async ({ playbook_id }) => {
-            try {
-                await this.callBackendAPI(`/api/playbooks/${encodeURIComponent(playbook_id)}`, {
-                    method: 'DELETE',
-                });
-                return this.toolResult({ success: true, playbook_id });
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("create_deck", {
-            title: "Create Deck",
-            description: "Create a new deck in Agent Deck",
-            inputSchema: {
-                name: zod_1.z.string(),
-                description: zod_1.z.string().optional(),
-            },
-        }, async ({ name, description }) => {
-            try {
-                const deck = await this.callBackendAPI('/api/decks', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ name, description }),
-                });
-                return this.toolResult(deck);
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        // Remove duplicate old tools block - list_service_tools follows
-        this.registerTool("list_service_tools", {
-            title: "List Service Tools",
-            description: "List all available tools for a specific service in the active deck",
-            inputSchema: { serviceId: zod_1.z.string() }
-        }, async ({ serviceId }) => {
-            try {
-                const tools = await this.callBackendAPI(`/api/services/${serviceId}/tools`);
-                return { content: [{ type: "text", text: JSON.stringify(tools, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
-        });
-        // Call a tool on a service in the active deck
-        this.registerTool("call_service_tool", {
-            title: "Call Service Tool",
-            description: "Call a tool on a service from the active deck",
-            inputSchema: {
-                serviceId: zod_1.z.string(),
-                toolName: zod_1.z.string(),
-                arguments: zod_1.z.union([zod_1.z.record(zod_1.z.any()), zod_1.z.string()]).optional()
-            }
-        }, async ({ serviceId, toolName, arguments: args = {} }) => {
-            try {
-                // Support both object and JSON string inputs for arguments
-                let normalizedArgs = args;
-                if (typeof normalizedArgs === 'string' && normalizedArgs.length > 0) {
-                    try {
-                        normalizedArgs = JSON.parse(normalizedArgs);
-                    }
-                    catch (e) {
-                        return { content: [{ type: "text", text: JSON.stringify({ error: `Invalid JSON in arguments: ${String(e)}` }, null, 2) }] };
-                    }
-                }
-                const res = await fetch(`${this.backendUrl}/api/services/${serviceId}/call`, {
-                    method: 'POST',
-                    headers: { ...this.getAgentHeaders(), 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ toolName, arguments: normalizedArgs ?? {} })
-                });
-                if (!res.ok) {
-                    const text = await res.text();
-                    throw new Error(`Backend API error ${res.status}: ${text}`);
-                }
-                const body = await res.json();
-                const data = (body && body.success) ? (body.data ?? body.result ?? body) : body;
-                return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
+        (0, register_1.registerMcpTools)({
+            registerTool: (name, config, handler) => this.registerTool(name, config, handler),
+            profile: this.toolProfile,
+            getSessionId: () => this.getSessionId(),
+            getAgentHeaders: () => this.getAgentHeaders(),
+            getBoundDeckId: () => this.getBoundDeckId(),
+            callBackendAPI: (endpoint, init) => this.callBackendAPI(endpoint, init),
+            fetchDeck: (deckId) => this.fetchDeck(deckId),
+            buildBindingPayload: (sessionId) => this.buildBindingPayload(sessionId),
+            registerLiveDisplay: (sessionId) => this.registerLiveDisplay(sessionId),
+            sessionBinding: this.sessionBinding,
+            badgeBySession: this.badgeBySession,
+            backendUrl: this.backendUrl,
+            toolResult: (data) => this.toolResult(data),
+            toolError: (error) => this.toolError(error),
         });
     }
     setupResources() {
@@ -1062,7 +439,8 @@ class AgentDeckMCPServer {
             res.json({
                 status: 'ok',
                 service: 'agent-deck-mcp-server',
-                backendUrl: this.backendUrl
+                backendUrl: this.backendUrl,
+                toolProfile: this.toolProfile,
             });
         });
         // Backend connectivity check