@tapicker/bridge 1.0.0 → 1.1.0

package/dist/mcp.js

@@ -1,15 +1,16 @@
 import { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
 import { VERSION } from './constants.js';
-import { dispatchCommand } from './commands.js';
+import { dispatchCommand, getCommandDefinition } from './commands.js';
+import { createHttpBridgeApi, parseBridgeUrl } from './http-client.js';
 import { BridgeError, safeError, safeSuccess } from './errors.js';
-import { TabTargetSchema, WorkflowStatusEventSchema } from './protocol/schema.js';
-import { connectWorkflowWatch, waitForWorkflowStatus, workflowWatchWebSocketUrl } from './workflow-watch.js';
-export function createBridgeMcpApi(bridge) {
+import { WorkflowStatusEventSchema, WorkflowStatusInputSchema, WorkflowStartInputSchema, WorkflowControlInputSchema, DataInputSchema, DataGetInputSchema, DataExportInputSchema, DataListInputSchema, DataPreviewInputSchema, UserMeInputSchema, WorkflowStatusWatchResultSchema, ExtensionListResultSchema, WorkflowLogInputSchema, WorkflowLogsInputSchema, WorkflowListInputSchema, WorkflowGetInputSchema, WorkflowCreateInputSchema, WorkflowUpdateInputSchema, WorkflowGuideInputSchema, WorkflowSchemaInputSchema, WorkflowValidateInputSchema, } from './protocol/schema.js';
+import { connectWorkflowStatusWatch, waitForWorkflowStatus, workflowStatusWatchWebSocketUrl } from './workflow-watch.js';
+export function createBridgeMcpApi(bridge, exports) {
     return {
-        executeCommand: (name, request) => dispatchCommand(name, request, { bridge }),
+        executeCommand: (name, request) => dispatchCommand(name, request, { bridge, exports }),
         listExtensions: async () => bridge.getExtensionStatuses(),
-        watchWorkflow: (input, onStatus, signal) => {
+        watchWorkflowStatus: (input, onStatus, signal) => {
             const clientId = bridge.resolveCommandClientId('workflow.status', input.clientId);
             return waitForWorkflowStatus({
                 clientId,
@@ -19,11 +20,11 @@ export function createBridgeMcpApi(bridge) {
                         if (event.clientId === clientId && event.workflowId === input.workflowId)
                             handleStatus(event);
                     };
-                    bridge.on('workflow.status', listener);
-                    return () => bridge.off('workflow.status', listener);
+                    bridge.on('workflow.status.changed', listener);
+                    return () => bridge.off('workflow.status.changed', listener);
                 },
                 readStatus: async () => {
-                    const status = await bridge.sendCommand('workflow.status.get', { workflowId: input.workflowId }, clientId);
+                    const status = await bridge.sendCommand('workflow.status', { workflowId: input.workflowId }, clientId);
                     return parseWorkflowStatusEvent(status, clientId, input.workflowId);
                 },
                 onStatus,
@@ -35,40 +36,11 @@ export function createBridgeMcpApi(bridge) {
 }
 export function createHttpMcpApi(baseUrl, token) {
     const bridgeUrl = parseBridgeUrl(baseUrl);
-    const headers = {};
-    if (token) {
-        headers.Authorization = `Bearer ${token}`;
-    }
-    const executeCommand = async (name, request) => {
-        const response = await fetchBridge(new URL(`/v1/commands/${encodeURIComponent(name)}`, bridgeUrl), {
-            method: 'POST',
-            headers: { ...headers, 'Content-Type': 'application/json' },
-            body: JSON.stringify(request),
-        });
-        const body = await readBridgeResponse(response);
-        if (!response.ok || !body.ok) {
-            throw new BridgeError(body.error?.code ?? 'BridgeRequestFailed', body.error?.message ?? response.statusText, {
-                status: response.status,
-                details: body.error?.details,
-            });
-        }
-        return body.data;
-    };
+    const api = createHttpBridgeApi(baseUrl, token);
     return {
-        executeCommand,
-        listExtensions: async () => {
-            const response = await fetchBridge(new URL('/v1/extensions', bridgeUrl), { headers });
-            const body = await readBridgeResponse(response);
-            if (!response.ok || !Array.isArray(body.extensions)) {
-                throw new BridgeError(body.error?.code ?? 'BridgeRequestFailed', body.error?.message ?? response.statusText, {
-                    status: response.status,
-                    details: body.error?.details,
-                });
-            }
-            return body.extensions;
-        },
-        watchWorkflow: async (input, onStatus, signal) => {
-            const connection = await connectWorkflowWatch(workflowWatchWebSocketUrl(bridgeUrl), { clientId: input.clientId, workflowId: input.workflowId }, token, signal);
+        ...api,
+        watchWorkflowStatus: async (input, onStatus, signal) => {
+            const connection = await connectWorkflowStatusWatch(workflowStatusWatchWebSocketUrl(bridgeUrl), { clientId: input.clientId, workflowId: input.workflowId }, token, signal);
             try {
                 return await waitForWorkflowStatus({
                     clientId: connection.clientId,
@@ -82,7 +54,7 @@ export function createHttpMcpApi(baseUrl, token) {
                         };
                     },
                     readStatus: async () => {
-                        const status = await executeCommand('workflow.status', {
+                        const status = await api.executeCommand('workflow.status', {
                             clientId: connection.clientId,
                             input: { workflowId: input.workflowId },
                         });
@@ -101,88 +73,240 @@ export function createHttpMcpApi(baseUrl, token) {
 }
 export function createTapickerMcpServer(api) {
     const server = new McpServer({ name: 'tapicker-bridge', version: VERSION });
-    server.registerTool('extensions_list', {
+    server.registerTool('extension_list', {
         title: 'List connected Extensions',
-        description: 'List connected Tapicker Extensions and their clientId values for targeting Workflow commands.',
+        description: 'List connected Tapicker Extensions and their account snapshots when available. Choose a ready Extension by username or client name and use its clientId in subsequent commands.',
         inputSchema: z.object({}).strict(),
+        outputSchema: z.object({ ok: z.literal(true), data: ExtensionListResultSchema }).strict(),
+        annotations: { readOnlyHint: true },
+    }, async () => runTool(async () => ({ extensions: await api.listExtensions() })));
+    server.registerTool('workflow_guide', {
+        title: 'Read Workflow authoring guide',
+        description: 'Before generating or modifying Tapicker Workflow nodes, read topic overview (the default). Read related node and shared documentation by calling this tool with references.topic from a previous result. content preserves Markdown; source links are implementation references. Reuse the returned clientId for later calls.',
+        outputSchema: commandOutputSchema('workflow.guide'),
+        inputSchema: WorkflowGuideInputSchema.safeExtend({
+            clientId: z
+                .uuid()
+                .optional()
+                .describe('Target Extension UUID; required when multiple Extensions are connected.'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, async ({ clientId, ...input }) => runTool(() => api.executeCommand('workflow.guide', { clientId, input })));
+    server.registerTool('workflow_schema', {
+        title: 'Get Workflow document schema',
+        description: 'Get the JSON Schema for building or editing Tapicker Workflow documents. Read workflow_guide for node behavior, then pass the nodeTypes you plan to use, such as NodeLoop and NodeExtractData. Omit nodeTypes for all supported business nodes. Returns a self-contained draft 2020-12 schema in schema. Defaults do not fill omitted fields. Check generated documents with workflow_validate; schema validation does not prove real-page execution. Reuse the returned clientId.',
+        outputSchema: commandOutputSchema('workflow.schema'),
+        inputSchema: WorkflowSchemaInputSchema.safeExtend({
+            clientId: z
+                .uuid()
+                .optional()
+                .describe('Target Extension UUID; required when multiple Extensions are connected.'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, async ({ clientId, ...input }) => runTool(() => api.executeCommand('workflow.schema', { clientId, input })));
+    server.registerTool('workflow_validate', {
+        title: 'Validate Workflow document',
+        description: 'Validate an Editor clipboard document before pasting, creating, or updating a Workflow. In fragment, pass a parsed version 1 tapicker/nodes document with nodes, or a tapicker/workflow document with a workflow object containing at least one of name, intro, href, or nodes. Use workflow_schema for the document shapes. Fix any issues identified by path, code, and optional nodeId. On success, normalized nodes are returned when supplied. Pass nodes directly to workflow_create or workflow_update. Does not save, run, access pages, execute templates, or request browser permissions. Static validation does not prove real-page execution. Reuse the returned clientId.',
+        outputSchema: commandOutputSchema('workflow.validate'),
+        inputSchema: WorkflowValidateInputSchema.safeExtend({
+            clientId: z
+                .uuid()
+                .optional()
+                .describe('Target Extension UUID; required when multiple Extensions are connected.'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, async ({ clientId, ...input }) => runTool(() => api.executeCommand('workflow.validate', { clientId, input })));
+    server.registerTool('workflow_list', {
+        title: 'List Workflows',
+        description: 'Find your Workflows through the connected Extension account. scope defaults to own; shared includes accessible shared/public Workflows, pinned lists pinned entries. name filters fullname by substring. host matches the exact site host, such as example.com or localhost:3000, without a scheme or path; it excludes generic * Workflows unless host is *. Omit host for all sites. name and host filters are combined. page defaults to 1 and pageSize to 20 (max 100). Returns summaries identified by id and fullname, without nodes; an empty workflows array ends pagination. Do not run or edit deleted entries. Use id as workflowId in later calls. Reading nodes with workflow_get requires view, edit, or manage permission. Reuse the returned clientId.',
+        outputSchema: commandOutputSchema('workflow.list'),
+        inputSchema: WorkflowListInputSchema.safeExtend({
+            clientId: z
+                .uuid()
+                .optional()
+                .describe('Target Extension UUID; required when multiple Extensions are connected.'),
+        }),
         annotations: { readOnlyHint: true },
-    }, async () => runTool(() => api.listExtensions()));
+    }, async ({ clientId, ...input }) => runTool(() => api.executeCommand('workflow.list', { clientId, input })));
+    server.registerTool('workflow_get', {
+        title: 'Read Workflow',
+        description: 'Read the latest saved Workflow metadata and startup argument definitions in workflow.args. Pass the id returned by workflow_list. Use the declared names and types to supply values to workflow_start. With use-only permission, workflow.nodes is empty because the saved nodes are hidden. View, edit, or manage permission returns the full nodes. To update with edit or manage permission, pass the returned workflow.revision when available and reuse clientId.',
+        outputSchema: commandOutputSchema('workflow.get'),
+        inputSchema: WorkflowGetInputSchema.safeExtend({
+            clientId: z
+                .uuid()
+                .optional()
+                .describe('Target Extension UUID; required when multiple Extensions are connected.'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, async ({ clientId, ...input }) => runTool(() => api.executeCommand('workflow.get', { clientId, input })));
+    server.registerTool('workflow_create', {
+        title: 'Create Workflow',
+        description: 'Create a private Workflow in the selected Extension account. Use workflow_update to change an existing Workflow. Provide name and nodes. Use workflow_schema to look up node fields and workflow_validate to check a document before saving. Creation validates and saves without running. Reuse workflowId and clientId for later calls. If the response is lost, search workflow_list with scope own and the requested name in the same Extension, then use workflow_get to verify matching content before retrying.',
+        outputSchema: commandOutputSchema('workflow.create'),
+        inputSchema: WorkflowCreateInputSchema.safeExtend({
+            clientId: z
+                .uuid()
+                .optional()
+                .describe('Target Extension UUID; required when multiple Extensions are connected.'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
+    }, async ({ clientId, ...input }) => runTool(() => api.executeCommand('workflow.create', { clientId, input })));
+    server.registerTool('workflow_update', {
+        title: 'Update Workflow',
+        description: 'Update a saved Workflow with edit or manage permission. First call workflow_get, then reuse its clientId and pass the Workflow ID and revision you read. Provide at least one of name, intro, href, or nodes. Omitted fields are preserved. Supplying nodes replaces the entire node tree after validation. Returns the new revision without running the Workflow. On WorkflowConflict, read the latest content and reconcile your changes before retrying. If the response is lost, read the Workflow to check whether the changes were saved.',
+        outputSchema: commandOutputSchema('workflow.update'),
+        inputSchema: WorkflowUpdateInputSchema.safeExtend({
+            clientId: z
+                .uuid()
+                .optional()
+                .describe('Target Extension UUID; required when multiple Extensions are connected.'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false },
+    }, async ({ clientId, ...input }) => runTool(() => api.executeCommand('workflow.update', { clientId, input })));
     server.registerTool('workflow_start', {
         title: 'Start Workflow',
-        description: 'Start a Workflow in a connected Tapicker Extension. Returns the workflowId, full workflowName, and target clientId. If multiple Extensions are connected, provide clientId.',
-        inputSchema: z
-            .object({
-            workflowId: z.string().min(1).describe('The Workflow ID to start.'),
-            args: z.record(z.string(), z.unknown()).optional().describe('Optional Workflow input arguments.'),
-            tab: TabTargetSchema.optional().describe('Browser tab target; defaults to the active tab.'),
+        description: 'Start a saved Workflow in the selected Extension. Use workflow_get to discover its startup argument definitions, then pass input values in args keyed by their exact declared names. Omit values to use the Workflow defaults. Startup uses the active browser tab as its starting point. The receipt includes runAt for the accepted run. Reuse clientId and workflowId with workflow_status_watch, and compare runAt with the receipt. If the response is lost, check workflow_status before retrying. Set args.isClearData to true only to clear existing saved tables used by this Workflow and its enabled child Workflows.',
+        outputSchema: commandOutputSchema('workflow.start'),
+        inputSchema: WorkflowStartInputSchema.safeExtend({
             clientId: z
                 .uuid()
                 .optional()
                 .describe('Target Extension UUID; required when multiple Extensions are connected.'),
-        })
-            .strict(),
+        }),
         annotations: { destructiveHint: true },
     }, async ({ clientId, ...input }) => runTool(() => api.executeCommand('workflow.start', { clientId, input })));
+    const controlDescriptions = {
+        pause: 'Pause the active Workflow instance at its next pause point. An already paused instance stays paused.',
+        resume: 'Resume the same paused Workflow instance. An already running instance continues. Use workflow_start to begin a new run after it stops.',
+        stop: 'Request a stop for the active Workflow instance, including a paused instance. Succeeds when there is no active instance. Use workflow_status_watch to confirm cleanup by waiting for stopped.',
+    };
     for (const action of ['pause', 'resume', 'stop']) {
         server.registerTool(`workflow_${action}`, {
             title: `${capitalize(action)} Workflow`,
-            description: `${capitalize(action)} a Workflow by workflowId. If multiple Extensions are connected, provide clientId.`,
-            inputSchema: z
-                .object({
-                workflowId: z.string().min(1).describe('The Workflow ID to control.'),
+            description: `${controlDescriptions[action]} Reuse workflowId and clientId from the start receipt.`,
+            outputSchema: commandOutputSchema(`workflow.${action}`),
+            inputSchema: WorkflowControlInputSchema.safeExtend({
                 clientId: z
                     .uuid()
                     .optional()
                     .describe('Target Extension UUID; required when multiple Extensions are connected.'),
-            })
-                .strict(),
+            }),
             annotations: action === 'stop' ? { destructiveHint: true } : undefined,
         }, async ({ clientId, ...input }) => runTool(() => api.executeCommand(`workflow.${action}`, { clientId, input })));
     }
     server.registerTool('workflow_status', {
-        title: 'Get Workflow status',
-        description: 'Get the current or most recently persisted status for a Workflow. If multiple Extensions are connected, provide clientId.',
-        inputSchema: z
-            .object({
-            workflowId: z.string().min(1).describe('The Workflow ID to query.'),
+        title: 'Get Workflow Status',
+        description: 'Read the latest recorded status for a Workflow in the selected Extension. Reuse workflowId and clientId from the start receipt. Use runAt, when present, to identify the run or query its logs with workflow_logs. A stopped run succeeded only if reason is completed. Use workflow_status_watch to wait for execution to finish. After it stops, pass includeDataSummary: true and the observed runAt to find the tables changed by that run.',
+        outputSchema: commandOutputSchema('workflow.status'),
+        inputSchema: WorkflowStatusInputSchema.safeExtend({
             clientId: z
                 .uuid()
                 .optional()
                 .describe('Target Extension UUID; required when multiple Extensions are connected.'),
-        })
-            .strict(),
+        }),
         annotations: { readOnlyHint: true },
     }, async ({ clientId, ...input }) => runTool(() => api.executeCommand('workflow.status', { clientId, input })));
+    server.registerTool('workflow_logs', {
+        title: 'Query Workflow Logs',
+        description: 'Read a page of log previews from the latest run. Without a cursor, returns the newest matching page in ascending ID order. Use before with the first returned ID for older logs, or after with the last ID for newer logs. Reuse clientId, runAt when available, and the same level filter across pages. If detailsTruncated is true, pass the entry’s id as logId to workflow_log for full details.',
+        outputSchema: commandOutputSchema('workflow.logs'),
+        inputSchema: WorkflowLogsInputSchema.safeExtend({
+            clientId: z
+                .uuid()
+                .optional()
+                .describe('Target Extension UUID; required when multiple Extensions are connected.'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, async ({ clientId, ...input }) => runTool(() => api.executeCommand('workflow.logs', { clientId, input })));
+    server.registerTool('workflow_log', {
+        title: 'Get Workflow Log',
+        description: 'Read one log entry with full readable details. Pass the entry’s id from workflow_logs as logId, and reuse its workflowId, clientId, and runAt when available.',
+        outputSchema: commandOutputSchema('workflow.log'),
+        inputSchema: WorkflowLogInputSchema.extend({
+            clientId: z
+                .uuid()
+                .optional()
+                .describe('Target Extension UUID; required when multiple Extensions are connected.'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, async ({ clientId, ...input }) => runTool(() => api.executeCommand('workflow.log', { clientId, input })));
+    server.registerTool('data_list', {
+        title: 'List Data Tables',
+        description: 'Find saved data tables by table name or exact owning Workflow ID. Each table includes its ordered columnNames. This returns metadata without consuming export quota. Defaults to page 1 with 20 tables. Continue with the next page when hasMore is true. Reuse clientId and tableId with data_preview to inspect a sample or data_get to read rows.',
+        outputSchema: commandOutputSchema('data.list'),
+        inputSchema: DataListInputSchema.safeExtend({
+            clientId: z
+                .uuid()
+                .optional()
+                .describe('Target Extension UUID; required when multiple Extensions are connected.'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, async ({ clientId, ...input }) => runTool(() => api.executeCommand('data.list', { clientId, input })));
+    server.registerTool('data_preview', {
+        title: 'Preview Extracted Data',
+        description: 'Inspect up to 10 saved rows without consuming export quota. Use tableId from data_list or a run data summary. sample defaults to oldest; latest selects the most recently inserted rows. Both return rows in ascending ID order. columnNames and rowCount describe the table. isTruncated indicates the size limit omitted sample rows. Use data_get for more rows.',
+        outputSchema: commandOutputSchema('data.preview'),
+        inputSchema: DataPreviewInputSchema.safeExtend({
+            clientId: z
+                .uuid()
+                .optional()
+                .describe('Target Extension UUID; required when multiple Extensions are connected.'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, async ({ clientId, ...input }) => runTool(() => api.executeCommand('data.preview', { clientId, input })));
     server.registerTool('data_get', {
-        title: 'Get extracted data',
-        description: 'Get all rows from an extracted data table by tableId. This consumes the export row quota of the connected Extension account. If multiple Extensions are connected, provide clientId.',
-        inputSchema: z
-            .object({
-            tableId: z.string().trim().min(1).max(128).describe('The data table ID copied from Tapicker Data.'),
+        title: 'Get Extracted Data',
+        description: 'Read saved rows from Tapicker Data using the table ID from data_list or Copy ID. Defaults to page 1 with 50 rows. Use hasMore to continue with the next page and reuse clientId and pageSize. Set all to true for a small table that fits in one response. rowCount is the total recorded for the table. Returned rows consume export quota; use data_preview for a free sample. If the response is lost, quota may already have been deducted.',
+        outputSchema: commandOutputSchema('data.get'),
+        inputSchema: DataGetInputSchema.safeExtend({
             clientId: z
                 .uuid()
                 .optional()
                 .describe('Target Extension UUID; required when multiple Extensions are connected.'),
-        })
-            .strict(),
-    }, async ({ clientId, tableId }) => runTool(() => api.executeCommand('data.get', { clientId, input: { tableId } })));
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
+    }, async ({ clientId, ...input }) => runTool(() => api.executeCommand('data.get', { clientId, input })));
+    server.registerTool('data_export', {
+        title: 'Export Data Table',
+        description: 'Export a whole saved table as a file. Get its tableId from data_list. Choose xlsx, xls, csv, json, xml, or txt; the default is csv. The receipt contains the filename, rowCount, and an expiring downloadPath on the same Bridge. Download with the same Bridge authorization. Exporting consumes row quota; downloading the same file again does not. If the export response is lost, quota may already have been deducted.',
+        outputSchema: commandOutputSchema('data.export'),
+        inputSchema: DataExportInputSchema.safeExtend({
+            clientId: z
+                .uuid()
+                .optional()
+                .describe('Target Extension UUID; required when multiple Extensions are connected.'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
+    }, async ({ clientId, ...input }) => runTool(() => api.executeCommand('data.export', { clientId, input })));
     server.registerTool('data_delete', {
-        title: 'Delete extracted data',
-        description: 'Delete an extracted data table and remove it from Tapicker Data by tableId. If multiple Extensions are connected, provide clientId.',
-        inputSchema: z
-            .object({
-            tableId: z.string().trim().min(1).max(128).describe('The data table ID copied from Tapicker Data.'),
+        title: 'Delete Extracted Data',
+        description: 'Delete an entire saved table and its rows from Tapicker Data. Pass the table ID from Copy ID and select the Extension that holds the table. Confirm the intended table before deleting. On DataTableInUse, wait for the current operation to finish. If the response is lost, verify the table before retrying, since a later Workflow run can recreate it under the same ID.',
+        outputSchema: commandOutputSchema('data.delete'),
+        inputSchema: DataInputSchema.safeExtend({
             clientId: z
                 .uuid()
                 .optional()
                 .describe('Target Extension UUID; required when multiple Extensions are connected.'),
-        })
-            .strict(),
-        annotations: { destructiveHint: true },
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false },
     }, async ({ clientId, tableId }) => runTool(() => api.executeCommand('data.delete', { clientId, input: { tableId } })));
-    server.registerTool('workflow_watch', {
-        title: 'Wait for Workflow completion',
-        description: 'Listen for Workflow status changes until it completes, stops, or fails. Returns the latest status when timeoutMs is reached. If multiple Extensions are connected, provide clientId.',
+    server.registerTool('user_me', {
+        title: 'Get Current Tapicker User',
+        description: 'Read the current Tapicker account and plan for the selected Extension. Returns user with id, username, and plan. On SignInRequired, ask the user to sign in to Tapicker in that Extension. EmailNotVerified and AccountBanned identify account restrictions.',
+        outputSchema: commandOutputSchema('user.me'),
+        inputSchema: UserMeInputSchema.safeExtend({
+            clientId: z
+                .uuid()
+                .optional()
+                .describe('Target Extension UUID; required when multiple Extensions are connected.'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, async ({ clientId }) => runTool(() => api.executeCommand('user.me', { clientId, input: {} })));
+    server.registerTool('workflow_status_watch', {
+        title: 'Watch Workflow Status',
+        description: 'Subscribe first, then query the current status and wait for changes until stopped, timeout, or cancellation. Does not start the Workflow; an already stopped snapshot returns immediately. Cancellation only stops waiting. The result has isTimedOut set to true when the wait reaches its time limit. reason identifies how execution ended. If multiple Extensions are connected, provide clientId.',
+        outputSchema: z.object({ ok: z.literal(true), data: WorkflowStatusWatchResultSchema }).strict(),
         inputSchema: z
             .object({
             workflowId: z.string().min(1).describe('The Workflow ID to watch.'),
@@ -205,7 +329,7 @@ export function createTapickerMcpServer(api) {
         let progress = 0;
         let notificationQueue = Promise.resolve();
         return runTool(async () => {
-            const result = await api.watchWorkflow({ clientId, workflowId, timeoutMs }, (event) => {
+            const result = await api.watchWorkflowStatus({ clientId, workflowId, timeoutMs }, (event) => {
                 if (progressToken === undefined)
                     return;
                 progress += 1;
@@ -215,7 +339,7 @@ export function createTapickerMcpServer(api) {
                     params: {
                         progressToken,
                         progress,
-                        message: `Workflow status: ${event.state}`,
+                        message: `Workflow status: ${event.status}${event.reason ? ` (${event.reason})` : ''}`,
                     },
                 }))
                     .catch(() => undefined);
@@ -227,7 +351,7 @@ export function createTapickerMcpServer(api) {
     return server;
 }
 function parseWorkflowStatusEvent(value, clientId, workflowId) {
-    const parsed = WorkflowStatusEventSchema.safeParse({ ...value, clientId });
+    const parsed = WorkflowStatusEventSchema.strip().safeParse({ ...value, clientId });
     if (!parsed.success || parsed.data.workflowId !== workflowId) {
         throw new BridgeError('InvalidExtensionResponse', 'Extension returned an invalid workflow status response', {
             status: 502,
@@ -239,55 +363,18 @@ function parseWorkflowStatusEvent(value, clientId, workflowId) {
 function capitalize(value) {
     return `${value[0].toUpperCase()}${value.slice(1)}`;
 }
-function parseBridgeUrl(value) {
-    let url;
-    try {
-        url = new URL(value);
-    }
-    catch (cause) {
-        throw new BridgeError('InvalidBridgeUrl', 'Bridge URL must be a valid HTTP or HTTPS URL', { status: 400, cause });
-    }
-    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
-        throw new BridgeError('InvalidBridgeUrl', 'Bridge URL must use HTTP or HTTPS', { status: 400 });
-    }
-    if (url.username || url.password || url.pathname !== '/' || url.search || url.hash) {
-        throw new BridgeError('InvalidBridgeUrl', 'Bridge URL must contain only the HTTP(S) origin and port', {
-            status: 400,
-        });
-    }
-    return url;
-}
-async function fetchBridge(url, init) {
-    try {
-        return await fetch(url, { ...init, signal: AbortSignal.timeout(30_000) });
-    }
-    catch (cause) {
-        throw new BridgeError('BridgeUnavailable', `Unable to reach Tapicker Bridge at ${url.origin}`, {
-            status: 503,
-            cause,
-        });
-    }
-}
-async function readBridgeResponse(response) {
-    let body;
-    try {
-        body = (await response.json());
-    }
-    catch (cause) {
-        throw new BridgeError('InvalidBridgeResponse', 'Bridge returned an invalid JSON response', {
-            status: 502,
-            cause,
-        });
-    }
-    if (!body || typeof body !== 'object') {
-        throw new BridgeError('InvalidBridgeResponse', 'Bridge returned an invalid response', { status: 502 });
-    }
-    return body;
+/**
+ * 复用命令的结果 Schema，仅声明稳定结构，不内嵌 Workflow 节点业务定义。
+ */
+function commandOutputSchema(name) {
+    return z.object({ ok: z.literal(true), data: getCommandDefinition(name).resultSchema }).strict();
 }
 async function runTool(operation) {
     try {
+        const result = safeSuccess(await operation());
         return {
-            content: [{ type: 'text', text: JSON.stringify(safeSuccess(await operation()), null, 2) }],
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            structuredContent: result,
         };
     }
     catch (error) {