@frontmcp/sdk 0.6.0 → 0.6.2

package/src/tool/flows/call-tool.flow.js

@@ -1,616 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-// tools/flows/call-tool.flow.ts
-const crypto_1 = require("crypto");
-const common_1 = require("../../common");
-const zod_1 = require("zod");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
-const errors_1 = require("../../errors");
-const ui_1 = require("../ui");
-const adapters_1 = require("@frontmcp/ui/adapters");
-const registry_1 = require("@frontmcp/ui/registry");
-const inputSchema = zod_1.z.object({
-    request: types_js_1.CallToolRequestSchema,
-    // z.any() used because ctx is the MCP SDK's ToolCallExtra type which varies by SDK version
-    ctx: zod_1.z.any(),
-});
-const outputSchema = types_js_1.CallToolResultSchema;
-const stateSchema = zod_1.z.object({
-    input: zod_1.z.looseObject({
-        name: zod_1.z.string().min(1).max(64),
-        arguments: zod_1.z.looseObject({}).optional(),
-    }),
-    authInfo: zod_1.z.any().optional(),
-    tool: zod_1.z.instanceof(common_1.ToolEntry),
-    toolContext: zod_1.z.instanceof(common_1.ToolContext),
-    // Store the raw executed output for plugins to see
-    rawOutput: zod_1.z.any().optional(),
-    output: outputSchema,
-    // Tool owner ID for hook filtering (set during parseInput)
-    _toolOwnerId: zod_1.z.string().optional(),
-    // UI result from applyUI stage (if UI config exists)
-    uiResult: zod_1.z.any().optional(),
-    // UI metadata from rendering (merged into _meta)
-    uiMeta: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
-});
-const plan = {
-    pre: [
-        'parseInput',
-        'findTool',
-        'checkToolAuthorization',
-        'createToolCallContext',
-        'acquireQuota',
-        'acquireSemaphore',
-    ],
-    execute: ['validateInput', 'execute', 'validateOutput'],
-    finalize: ['releaseSemaphore', 'releaseQuota', 'applyUI', 'finalize'],
-};
-const name = 'tools:call-tool';
-const { Stage } = (0, common_1.FlowHooksOf)(name);
-let CallToolFlow = class CallToolFlow extends common_1.FlowBase {
-    logger = this.scopeLogger.child('CallToolFlow');
-    async parseInput() {
-        this.logger.verbose('parseInput:start');
-        let method;
-        // NOTE: `any` is intentional - Zod parsing validates these values
-        // Using unknown would require redundant type guards after schema validation
-        let params;
-        let ctx;
-        try {
-            const inputData = inputSchema.parse(this.rawInput);
-            method = inputData.request.method;
-            params = inputData.request.params;
-            ctx = inputData.ctx;
-        }
-        catch (e) {
-            throw new errors_1.InvalidInputError('Invalid Input', e instanceof zod_1.z.ZodError ? e.issues : undefined);
-        }
-        if (method !== 'tools/call') {
-            this.logger.warn(`parseInput: invalid method "${method}"`);
-            throw new errors_1.InvalidMethodError(method, 'tools/call');
-        }
-        // Find the tool early to get its owner ID for hook filtering
-        const { name } = params;
-        const activeTools = this.scope.tools.getTools(true);
-        const tool = activeTools.find((entry) => {
-            return entry.fullName === name || entry.name === name;
-        });
-        // Store tool owner ID in state for hook filtering
-        const toolOwnerId = tool?.owner?.id;
-        this.state.set({ input: params, authInfo: ctx.authInfo, _toolOwnerId: toolOwnerId });
-        this.logger.verbose('parseInput:done');
-    }
-    async findTool() {
-        this.logger.verbose('findTool:start');
-        // TODO: add support for session based tools
-        const activeTools = this.scope.tools.getTools(true);
-        this.logger.info(`findTool: discovered ${activeTools.length} active tool(s) (including hidden)`);
-        const { name } = this.state.required.input;
-        const tool = activeTools.find((entry) => {
-            return entry.fullName === name || entry.name === name;
-        });
-        if (!tool) {
-            this.logger.warn(`findTool: tool "${name}" not found`);
-            throw new errors_1.ToolNotFoundError(name);
-        }
-        this.logger = this.logger.child(`CallToolFlow(${name})`);
-        this.state.set('tool', tool);
-        this.logger.info(`findTool: tool "${name}" found`);
-        this.logger.verbose('findTool:done');
-    }
-    /**
-     * Check if the tool's parent app is authorized.
-     * For progressive authorization, tools from unauthorized apps
-     * return an AuthorizationRequiredError with an auth_url.
-     */
-    async checkToolAuthorization() {
-        this.logger.verbose('checkToolAuthorization:start');
-        const { tool, authInfo } = this.state;
-        // Get authorization from authInfo.extra if available
-        const authorization = authInfo?.extra?.['authorization'];
-        // No auth context = public mode, skip authorization check
-        if (!authorization) {
-            this.logger.verbose('checkToolAuthorization:skip (no auth context)');
-            return;
-        }
-        // Get app ID from tool owner (uses existing lineage system)
-        const appId = tool?.owner?.id;
-        if (!appId) {
-            // Tool has no owner = global tool, skip app-level authorization check
-            this.logger.verbose('checkToolAuthorization:skip (no owner)');
-            return;
-        }
-        // Check if app is authorized using existing session structure
-        const isAppAuthorized = authorization.authorizedAppIds?.includes(appId) || appId in (authorization.authorizedApps || {});
-        if (!isAppAuthorized) {
-            // Get incremental auth configuration from scope's auth options
-            const apps = this.scope.apps.getApps();
-            const app = apps.find((a) => a.metadata.id === appId);
-            const authOptions = this.scope.auth?.options;
-            // Determine skippedAppBehavior:
-            // 1. Only applies in orchestrated mode with incrementalAuth configured
-            // 2. Default to 'anonymous' if not configured (allow anonymous fallback)
-            let skippedBehavior = 'anonymous';
-            if (authOptions && (0, common_1.isOrchestratedMode)(authOptions)) {
-                // Orchestrated mode - check incrementalAuth config
-                const incrementalConfig = authOptions.incrementalAuth;
-                if (incrementalConfig) {
-                    // If incremental auth is disabled, always require auth
-                    if (incrementalConfig.enabled === false) {
-                        skippedBehavior = 'require-auth';
-                    }
-                    else {
-                        skippedBehavior = incrementalConfig.skippedAppBehavior || 'anonymous';
-                    }
-                }
-                // If incrementalAuth not configured, default is enabled with 'anonymous' behavior
-            }
-            // For public/transparent modes, default 'anonymous' behavior applies
-            if (skippedBehavior === 'anonymous' && app?.metadata?.auth?.mode === 'public') {
-                // App supports anonymous - continue with anonymous access
-                this.logger.verbose(`checkToolAuthorization: using anonymous for ${appId}`);
-                return;
-            }
-            // Require explicit authorization - build auth URL
-            const authUrl = this.buildProgressiveAuthUrl(appId, tool?.fullName || '');
-            this.logger.info(`checkToolAuthorization: authorization required for app "${appId}"`);
-            throw new errors_1.AuthorizationRequiredError({
-                appId,
-                toolId: tool?.fullName || tool?.name || 'unknown',
-                authUrl,
-                message: `Authorization required for ${appId}. Please authorize to use ${tool?.fullName || tool?.name}.`,
-            });
-        }
-        this.logger.verbose('checkToolAuthorization:done');
-    }
-    /**
-     * Build the URL for progressive/incremental authorization
-     */
-    buildProgressiveAuthUrl(appId, toolId) {
-        const baseUrl = this.scope.fullPath || '';
-        return `${baseUrl}/oauth/authorize?app=${encodeURIComponent(appId)}&tool=${encodeURIComponent(toolId)}`;
-    }
-    async createToolCallContext() {
-        this.logger.verbose('createToolCallContext:start');
-        const { ctx } = this.input;
-        const { tool, input } = this.state.required;
-        try {
-            const context = tool.create(input.arguments, ctx);
-            const toolHooks = this.scope.hooks.getClsHooks(tool.record.provide).map((hook) => {
-                hook.run = async () => {
-                    return context[hook.metadata.method]();
-                };
-                return hook;
-            });
-            this.appendContextHooks(toolHooks);
-            context.mark('createToolCallContext');
-            this.state.set('toolContext', context);
-            this.logger.verbose('createToolCallContext:done');
-        }
-        catch (error) {
-            this.logger.error('createToolCallContext: failed to create context', error);
-            throw new errors_1.ToolExecutionError(tool.metadata.name, error instanceof Error ? error : undefined);
-        }
-    }
-    async acquireQuota() {
-        this.logger.verbose('acquireQuota:start');
-        // used for rate limiting
-        this.state.toolContext?.mark('acquireQuota');
-        this.logger.verbose('acquireQuota:done');
-    }
-    async acquireSemaphore() {
-        this.logger.verbose('acquireSemaphore:start');
-        // used for concurrency control
-        this.state.toolContext?.mark('acquireSemaphore');
-        this.logger.verbose('acquireSemaphore:done');
-    }
-    async validateInput() {
-        this.logger.verbose('validateInput:start');
-        const { tool, input } = this.state.required;
-        const { toolContext } = this.state;
-        if (!toolContext) {
-            return;
-        }
-        toolContext.mark('validateInput');
-        try {
-            toolContext.input = tool.parseInput(input);
-            this.logger.verbose('validateInput:done');
-        }
-        catch (err) {
-            if (err instanceof zod_1.z.ZodError) {
-                throw new errors_1.InvalidInputError('Invalid tool input', err.issues);
-            }
-            this.logger.error('validateInput: failed to parse input', err);
-            throw new errors_1.InvalidInputError('Unknown error occurred when trying to parse input');
-        }
-    }
-    async execute() {
-        this.logger.verbose('execute:start');
-        const toolContext = this.state.toolContext;
-        if (!toolContext) {
-            return;
-        }
-        toolContext.mark('execute');
-        try {
-            toolContext.output = await toolContext.execute(toolContext.input);
-            this.logger.verbose('execute:done');
-        }
-        catch (error) {
-            this.logger.error('execute: tool execution failed', error);
-            throw new errors_1.ToolExecutionError(this.state.tool?.metadata.name || 'unknown', error instanceof Error ? error : undefined);
-        }
-    }
-    async validateOutput() {
-        this.logger.verbose('validateOutput:start');
-        const { toolContext } = this.state;
-        if (!toolContext) {
-            return;
-        }
-        toolContext.mark('validateOutput');
-        // Store the RAW output for plugins (cache, PII, etc.) to inspect
-        this.state.set('rawOutput', toolContext.output);
-        this.logger.verbose('validateOutput:done');
-    }
-    async releaseSemaphore() {
-        this.logger.verbose('releaseSemaphore:start');
-        // release concurrency control
-        this.state.toolContext?.mark('releaseSemaphore');
-        this.logger.verbose('releaseSemaphore:done');
-    }
-    async releaseQuota() {
-        this.logger.verbose('releaseQuota:start');
-        // release rate limiting
-        this.state.toolContext?.mark('releaseQuota');
-        this.logger.verbose('releaseQuota:done');
-    }
-    /**
-     * Apply UI rendering to the tool response.
-     * This stage handles all UI-related logic including platform detection,
-     * serving mode resolution, and content formatting.
-     */
-    async applyUI() {
-        this.logger.verbose('applyUI:start');
-        const { tool, rawOutput, input } = this.state;
-        // Skip if no tool or no UI config
-        if (!tool || !(0, ui_1.hasUIConfig)(tool.metadata)) {
-            this.logger.verbose('applyUI:skip (no UI config)');
-            return;
-        }
-        try {
-            // Cast scope to Scope to access toolUI and notifications
-            const scope = this.scope;
-            // Get session info for platform detection from authInfo (already in state from parseInput)
-            const { authInfo } = this.state;
-            const sessionId = authInfo?.sessionId;
-            const requestId = (0, crypto_1.randomUUID)();
-            // Get platform type: first check sessionIdPayload (detected from user-agent),
-            // then fall back to notification service (detected from MCP clientInfo),
-            // finally default to 'unknown' (conservative: skip UI for unknown clients)
-            const platformType = authInfo?.sessionIdPayload?.platformType ??
-                (sessionId ? scope.notifications.getPlatformType(sessionId) : undefined) ??
-                'unknown';
-            // Resolve the effective serving mode based on configuration and client capabilities
-            // Default is 'auto' which selects the best mode for the platform
-            const configuredMode = tool.metadata.ui.servingMode ?? 'auto';
-            const resolvedMode = (0, adapters_1.resolveServingMode)({
-                configuredMode,
-                platformType,
-            });
-            // If client doesn't support UI (e.g., Gemini, unknown, or forced mode not available)
-            // skip UI rendering entirely
-            if (!resolvedMode.supportsUI || resolvedMode.effectiveMode === null) {
-                this.logger.verbose('applyUI: Skipping UI (client does not support it)', {
-                    tool: tool.metadata.name,
-                    platform: platformType,
-                    configuredMode,
-                    reason: resolvedMode.reason,
-                });
-                return;
-            }
-            const servingMode = resolvedMode.effectiveMode;
-            const useStructuredContent = resolvedMode.useStructuredContent;
-            let htmlContent;
-            let uiMeta = {};
-            if (servingMode === 'static') {
-                // For static mode: no additional rendering needed
-                // Widget was already registered at server startup
-                this.logger.verbose('applyUI: UI using static mode (structured data only)', {
-                    tool: tool.metadata.name,
-                    platform: platformType,
-                });
-            }
-            else if (servingMode === 'hybrid') {
-                // For hybrid mode: build the component payload
-                const componentPayload = scope.toolUI.buildHybridComponentPayload({
-                    toolName: tool.metadata.name,
-                    template: tool.metadata.ui.template,
-                    uiConfig: tool.metadata.ui,
-                });
-                if (componentPayload) {
-                    uiMeta = {
-                        'ui/component': componentPayload,
-                        'ui/type': componentPayload.type,
-                    };
-                }
-                this.logger.verbose('applyUI: UI using hybrid mode (structured data + component)', {
-                    tool: tool.metadata.name,
-                    platform: platformType,
-                    hasComponent: !!componentPayload,
-                    componentType: componentPayload?.type,
-                    componentHash: componentPayload?.hash,
-                });
-            }
-            else {
-                // For inline mode (default): render HTML with data embedded
-                const uiRenderResult = await scope.toolUI.renderAndRegisterAsync({
-                    toolName: tool.metadata.name,
-                    requestId,
-                    input: input?.arguments && typeof input.arguments === 'object' && !Array.isArray(input.arguments)
-                        ? input.arguments
-                        : {},
-                    output: rawOutput,
-                    structuredContent: undefined,
-                    uiConfig: tool.metadata.ui,
-                    platformType,
-                });
-                // Handle graceful degradation: rendering failed in production
-                if ((0, registry_1.isUIRenderFailure)(uiRenderResult)) {
-                    this.logger.warn('applyUI: UI rendering failed (graceful degradation)', {
-                        tool: tool.metadata.name,
-                        reason: uiRenderResult.reason,
-                        platform: platformType,
-                    });
-                    // Proceed without UI - tool result will not have ui/html metadata
-                    htmlContent = undefined;
-                    uiMeta = {};
-                }
-                else {
-                    // Extract HTML from platform-specific meta key
-                    const htmlKey = platformType === 'openai' ? 'openai/html' : platformType === 'ext-apps' ? 'ui/html' : 'frontmcp/html';
-                    htmlContent = uiRenderResult?.meta?.[htmlKey];
-                    // Fallback to ui/html for compatibility
-                    if (!htmlContent) {
-                        htmlContent = uiRenderResult?.meta?.['ui/html'];
-                    }
-                    uiMeta = uiRenderResult.meta || {};
-                }
-            }
-            // Build the response content using the extracted utility
-            const uiResult = (0, adapters_1.buildToolResponseContent)({
-                rawOutput,
-                htmlContent,
-                servingMode,
-                useStructuredContent,
-                platformType,
-            });
-            // Store UI result and metadata in state for finalize stage
-            this.state.set('uiResult', uiResult);
-            this.state.set('uiMeta', uiMeta);
-            this.logger.verbose('applyUI: UI processed', {
-                tool: tool.metadata.name,
-                platform: platformType,
-                servingMode,
-                useStructuredContent,
-                format: uiResult.format,
-                contentCleared: uiResult.contentCleared,
-            });
-        }
-        catch (error) {
-            // UI rendering failure should not fail the tool call
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const errorStack = error instanceof Error ? error.stack : undefined;
-            const uiConfig = tool.metadata.ui;
-            this.logger.error('applyUI: UI rendering failed', {
-                tool: tool.metadata.name,
-                error: errorMessage,
-                stack: errorStack,
-                templateType: uiConfig?.template
-                    ? typeof uiConfig.template === 'function'
-                        ? 'react-component'
-                        : typeof uiConfig.template === 'string'
-                            ? uiConfig.template.endsWith('.tsx') || uiConfig.template.endsWith('.jsx')
-                                ? 'react-file'
-                                : 'html-file'
-                            : 'unknown'
-                    : 'none',
-            });
-            // In debug mode, also log to console for immediate visibility
-            if (process.env['DEBUG'] || process.env['NODE_ENV'] === 'development') {
-                console.error('[FrontMCP] UI Rendering Error:', {
-                    tool: tool.metadata.name,
-                    error: errorMessage,
-                    stack: errorStack,
-                });
-            }
-        }
-        this.logger.verbose('applyUI:done');
-    }
-    /**
-     * Finalize the tool response.
-     * Validates output, applies UI result from applyUI stage, and sends the response.
-     *
-     * Note: This stage runs even when execute fails (as part of cleanup).
-     * If rawOutput is undefined, it means an error occurred during execution
-     * and the error will be propagated by the flow framework - we should not
-     * throw a new error here.
-     */
-    async finalize() {
-        this.logger.verbose('finalize:start');
-        const { tool, rawOutput, uiResult, uiMeta } = this.state;
-        if (!tool) {
-            // No tool found - this is an early failure, just skip finalization
-            this.logger.verbose('finalize: skipping (no tool in state)');
-            return;
-        }
-        if (rawOutput === undefined) {
-            // No output means execute stage failed - skip finalization
-            // The original error will be propagated by the flow framework
-            this.logger.verbose('finalize: skipping (no output - execute stage likely failed)');
-            return;
-        }
-        // Parse and construct the MCP-compliant output using safeParseOutput
-        const parseResult = tool.safeParseOutput(rawOutput);
-        if (!parseResult.success) {
-            this.logger.error('finalize: output validation failed', {
-                tool: tool.metadata.name,
-                errors: parseResult.error,
-            });
-            throw new errors_1.InvalidOutputError();
-        }
-        const result = parseResult.data;
-        // Apply UI result if available (from applyUI stage)
-        if (uiResult) {
-            result.content = uiResult.content;
-            // Set structuredContent from UI result (contains raw tool output)
-            // Cast to Record<string, unknown> since MCP protocol expects object type
-            if (uiResult.structuredContent !== undefined && uiResult.structuredContent !== null) {
-                result.structuredContent = uiResult.structuredContent;
-            }
-            if (uiMeta) {
-                result._meta = { ...result._meta, ...uiMeta };
-            }
-        }
-        // Log the final result being sent
-        this.logger.info('finalize: sending response', {
-            tool: tool.metadata.name,
-            hasContent: Array.isArray(result.content) && result.content.length > 0,
-            contentLength: Array.isArray(result.content) ? result.content.length : 0,
-            hasStructuredContent: result.structuredContent !== undefined,
-            hasMeta: result._meta !== undefined,
-            metaKeys: result._meta ? Object.keys(result._meta) : [],
-            isError: result.isError,
-        });
-        // Debug: Write full response to file if DEBUG_TOOL_RESPONSE is set
-        if (process.env['DEBUG_TOOL_RESPONSE']) {
-            // eslint-disable-next-line @typescript-eslint/no-require-imports
-            const fs = require('fs').promises;
-            // eslint-disable-next-line @typescript-eslint/no-require-imports
-            const os = require('os');
-            // eslint-disable-next-line @typescript-eslint/no-require-imports
-            const path = require('path');
-            const debugOutput = {
-                timestamp: new Date().toISOString(),
-                tool: tool.metadata.name,
-                rawOutput,
-                uiResult,
-                uiMeta,
-                finalResult: result,
-            };
-            // Use os.tmpdir() for cross-platform compatibility (works on Windows, macOS, Linux)
-            const tempDir = os.tmpdir();
-            const defaultPath = path.join(tempDir, 'tool-response-debug.json');
-            let outputPath = process.env['DEBUG_TOOL_RESPONSE_PATH'] || defaultPath;
-            // Path traversal protection: ensure custom path is within allowed directories
-            if (process.env['DEBUG_TOOL_RESPONSE_PATH']) {
-                const resolvedPath = path.resolve(outputPath);
-                const resolvedTempDir = path.resolve(tempDir);
-                const cwd = path.resolve(process.cwd());
-                // Only allow paths within temp directory or current working directory
-                const isInTempDir = resolvedPath.startsWith(resolvedTempDir + path.sep) || resolvedPath === resolvedTempDir;
-                const isInCwd = resolvedPath.startsWith(cwd + path.sep) || resolvedPath === cwd;
-                if (!isInTempDir && !isInCwd) {
-                    console.error(`[DEBUG] DEBUG_TOOL_RESPONSE_PATH must be within temp directory (${tempDir}) or current working directory (${cwd}). ` +
-                        `Falling back to default path.`);
-                    outputPath = defaultPath;
-                }
-            }
-            // Use async write to avoid blocking the event loop (fire-and-forget)
-            fs.writeFile(outputPath, JSON.stringify(debugOutput, null, 2))
-                .then(() => console.log(`[DEBUG] Tool response written to: ${outputPath}`))
-                .catch((err) => console.error(`[DEBUG] Failed to write tool response: ${err.message}`));
-        }
-        // Respond with the properly formatted MCP result
-        this.respond(result);
-        this.logger.verbose('finalize:done');
-    }
-};
-tslib_1.__decorate([
-    Stage('parseInput'),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", []),
-    tslib_1.__metadata("design:returntype", Promise)
-], CallToolFlow.prototype, "parseInput", null);
-tslib_1.__decorate([
-    Stage('findTool'),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", []),
-    tslib_1.__metadata("design:returntype", Promise)
-], CallToolFlow.prototype, "findTool", null);
-tslib_1.__decorate([
-    Stage('checkToolAuthorization'),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", []),
-    tslib_1.__metadata("design:returntype", Promise)
-], CallToolFlow.prototype, "checkToolAuthorization", null);
-tslib_1.__decorate([
-    Stage('createToolCallContext'),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", []),
-    tslib_1.__metadata("design:returntype", Promise)
-], CallToolFlow.prototype, "createToolCallContext", null);
-tslib_1.__decorate([
-    Stage('acquireQuota'),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", []),
-    tslib_1.__metadata("design:returntype", Promise)
-], CallToolFlow.prototype, "acquireQuota", null);
-tslib_1.__decorate([
-    Stage('acquireSemaphore'),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", []),
-    tslib_1.__metadata("design:returntype", Promise)
-], CallToolFlow.prototype, "acquireSemaphore", null);
-tslib_1.__decorate([
-    Stage('validateInput'),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", []),
-    tslib_1.__metadata("design:returntype", Promise)
-], CallToolFlow.prototype, "validateInput", null);
-tslib_1.__decorate([
-    Stage('execute'),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", []),
-    tslib_1.__metadata("design:returntype", Promise)
-], CallToolFlow.prototype, "execute", null);
-tslib_1.__decorate([
-    Stage('validateOutput'),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", []),
-    tslib_1.__metadata("design:returntype", Promise)
-], CallToolFlow.prototype, "validateOutput", null);
-tslib_1.__decorate([
-    Stage('releaseSemaphore'),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", []),
-    tslib_1.__metadata("design:returntype", Promise)
-], CallToolFlow.prototype, "releaseSemaphore", null);
-tslib_1.__decorate([
-    Stage('releaseQuota'),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", []),
-    tslib_1.__metadata("design:returntype", Promise)
-], CallToolFlow.prototype, "releaseQuota", null);
-tslib_1.__decorate([
-    Stage('applyUI'),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", []),
-    tslib_1.__metadata("design:returntype", Promise)
-], CallToolFlow.prototype, "applyUI", null);
-tslib_1.__decorate([
-    Stage('finalize'),
-    tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", []),
-    tslib_1.__metadata("design:returntype", Promise)
-], CallToolFlow.prototype, "finalize", null);
-CallToolFlow = tslib_1.__decorate([
-    (0, common_1.Flow)({
-        name,
-        plan,
-        inputSchema,
-        outputSchema,
-        access: 'authorized',
-    })
-], CallToolFlow);
-exports.default = CallToolFlow;
-//# sourceMappingURL=call-tool.flow.js.map