@pikku/inspector 0.9.6-next.0 → 0.10.1

package/dist/add/add-file-with-factory.js

@@ -1,9 +1,63 @@
 import * as ts from 'typescript';
-export const addFileWithFactory = (node, checker, methods = new Map(), expectedTypeName) => {
+import { extractServicesFromFunction } from '../utils/extract-services.js';
+// Mapping of wrapper function names to their corresponding types
+const wrapperFunctionMap = {
+    pikkuConfig: 'CreateConfig',
+    pikkuServices: 'CreateSingletonServices',
+    pikkuSessionServices: 'CreateSessionServices',
+};
+export const addFileWithFactory = (node, checker, methods = new Map(), expectedTypeName, state) => {
     if (ts.isVariableDeclaration(node)) {
         const fileName = node.getSourceFile().fileName;
         const variableTypeNode = node.type;
         const variableName = node.name.getText();
+        // Check for wrapper function calls FIRST (e.g., pikkuConfig(...), pikkuServices(...))
+        // This handles both cases: with and without explicit type annotations
+        if (node.initializer && ts.isCallExpression(node.initializer)) {
+            const callExpression = node.initializer;
+            const expression = callExpression.expression;
+            if (ts.isIdentifier(expression)) {
+                const wrapperFunctionName = expression.text;
+                const inferredType = wrapperFunctionMap[wrapperFunctionName];
+                if (inferredType === expectedTypeName) {
+                    // Get the type declaration path from the wrapper function
+                    const typeSymbol = checker.getSymbolAtLocation(expression);
+                    let typeDeclarationPath = null;
+                    if (typeSymbol &&
+                        typeSymbol.declarations &&
+                        typeSymbol.declarations[0]) {
+                        const declaration = typeSymbol.declarations[0];
+                        const sourceFile = declaration.getSourceFile();
+                        typeDeclarationPath = sourceFile.fileName;
+                    }
+                    const variables = methods.get(fileName) || [];
+                    variables.push({
+                        variable: variableName,
+                        type: inferredType,
+                        typePath: typeDeclarationPath,
+                    });
+                    methods.set(fileName, variables);
+                    // Extract singleton services for CreateSessionServices factories
+                    if (expectedTypeName === 'CreateSessionServices' &&
+                        state &&
+                        callExpression.arguments.length > 0) {
+                        const firstArg = callExpression.arguments[0];
+                        let functionNode;
+                        if (ts.isArrowFunction(firstArg)) {
+                            functionNode = firstArg;
+                        }
+                        else if (ts.isFunctionExpression(firstArg)) {
+                            functionNode = firstArg;
+                        }
+                        if (functionNode) {
+                            const servicesMeta = extractServicesFromFunction(functionNode);
+                            state.sessionServicesMeta.set(variableName, servicesMeta.services);
+                        }
+                    }
+                    return; // Early return since we found a match
+                }
+            }
+        }
         if (variableTypeNode && ts.isTypeReferenceNode(variableTypeNode)) {
             const typeNameNode = variableTypeNode.typeName || null;
             let typeDeclarationPath = null;
@@ -23,6 +77,22 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                     typePath: typeDeclarationPath,
                 });
                 methods.set(fileName, variables);
+                // Extract singleton services for CreateSessionServices factories
+                if (expectedTypeName === 'CreateSessionServices' &&
+                    state &&
+                    node.initializer) {
+                    let functionNode;
+                    if (ts.isArrowFunction(node.initializer)) {
+                        functionNode = node.initializer;
+                    }
+                    else if (ts.isFunctionExpression(node.initializer)) {
+                        functionNode = node.initializer;
+                    }
+                    if (functionNode) {
+                        const servicesMeta = extractServicesFromFunction(functionNode);
+                        state.sessionServicesMeta.set(variableName, servicesMeta.services);
+                    }
+                }
             }
             // Handle qualified type names if necessary
             else if (ts.isQualifiedName(typeNameNode)) {
@@ -41,6 +111,22 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                         typePath: typeDeclarationPath,
                     });
                     methods.set(fileName, variables);
+                    // Extract singleton services for CreateSessionServices factories
+                    if (expectedTypeName === 'CreateSessionServices' &&
+                        state &&
+                        node.initializer) {
+                        let functionNode;
+                        if (ts.isArrowFunction(node.initializer)) {
+                            functionNode = node.initializer;
+                        }
+                        else if (ts.isFunctionExpression(node.initializer)) {
+                            functionNode = node.initializer;
+                        }
+                        if (functionNode) {
+                            const servicesMeta = extractServicesFromFunction(functionNode);
+                            state.sessionServicesMeta.set(variableName, servicesMeta.services);
+                        }
+                    }
                 }
             }
         }

package/dist/add/add-functions.js

@@ -16,7 +16,7 @@ const nullifyTypes = (type) => {
     }
     return type;
 };
-const resolveTypeImports = (type, resolvedTypes, isCustom) => {
+const resolveTypeImports = (type, resolvedTypes, isCustom, checker) => {
     const types = [];
     const visitType = (currentType) => {
         const symbol = currentType.aliasSymbol || currentType.getSymbol();
@@ -27,9 +27,12 @@ const resolveTypeImports = (type, resolvedTypes, isCustom) => {
                 const sourceFile = declaration.getSourceFile();
                 const path = sourceFile.fileName;
                 // Skip built-in utility types or TypeScript lib types
+                // Skip enum members (but not the enum type itself)
+                const isEnumMember = declaration && ts.isEnumMember(declaration);
                 if (!path.includes('node_modules/typescript') &&
                     symbol.getName() !== '__type' &&
-                    !isPrimitiveType(currentType)) {
+                    !isPrimitiveType(currentType) &&
+                    !isEnumMember) {
                     const originalName = symbol.getName();
                     // Check if the type is already in the map
                     let uniqueName = resolvedTypes.exists(originalName, path);
@@ -76,6 +79,26 @@ const resolveTypeImports = (type, resolvedTypes, isCustom) => {
             const typeRef = currentType;
             typeRef.typeArguments?.forEach(visitType);
         }
+        // Handle anonymous object types with enum properties (e.g., { userType: UserType })
+        // Only traverse into enum property types to avoid over-importing other named types
+        if (currentType.flags & ts.TypeFlags.Object) {
+            const objectType = currentType;
+            const typeSymbol = objectType.getSymbol();
+            // Only traverse properties for anonymous object types (no symbol or __type symbol)
+            // Skip named types, interfaces, and enums to avoid over-importing
+            const isAnonymousObject = !typeSymbol || typeSymbol.getName() === '__type';
+            if (isAnonymousObject) {
+                const properties = objectType.getProperties();
+                for (const prop of properties) {
+                    if (prop.valueDeclaration) {
+                        const propType = checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration);
+                        if (propType) {
+                            visitType(propType);
+                        }
+                    }
+                }
+            }
+        }
     };
     visitType(type);
     return types;
@@ -125,7 +148,7 @@ const getNamesAndTypes = (checker, typesMap, direction, funcName, type) => {
         const aliasName = funcName.charAt(0).toUpperCase() + funcName.slice(1) + direction;
         // record the alias in your TypesMap
         const references = rawTypes
-            .map((t) => resolveTypeImports(t, typesMap, true))
+            .map((t) => resolveTypeImports(t, typesMap, true, checker))
             .flat();
         typesMap.addCustomType(aliasName, aliasType, references);
         return {
@@ -144,7 +167,7 @@ const getNamesAndTypes = (checker, typesMap, direction, funcName, type) => {
             return name;
         }
         // non-primitive: import/alias it inline
-        return resolveTypeImports(t, typesMap, false);
+        return resolveTypeImports(t, typesMap, false, checker);
     })
         .flat();
     return {
@@ -207,7 +230,7 @@ export const addFunctions = (logger, node, checker, state) => {
     }
     if (args.length === 0)
         return;
-    const { pikkuFuncName, name, explicitName, exportedName } = extractFunctionName(node, checker);
+    const { pikkuFuncName, name, explicitName, exportedName } = extractFunctionName(node, checker, state.rootDir);
     let tags;
     let expose;
     let docs;
@@ -226,6 +249,17 @@ export const addFunctions = (logger, node, checker, state) => {
         if (!fnProp ||
             (!ts.isArrowFunction(fnProp) && !ts.isFunctionExpression(fnProp))) {
             logger.error(`• No valid 'func' property found for ${pikkuFuncName}.`);
+            // Create stub metadata to prevent "function not found" errors in wirings
+            state.functions.meta[pikkuFuncName] = {
+                pikkuFuncName,
+                name,
+                services: { optimized: false, services: [] },
+                inputSchemaName: null,
+                outputSchemaName: null,
+                inputs: [],
+                outputs: [],
+                middleware: undefined,
+            };
             return;
         }
         handlerNode = fnProp;
@@ -233,6 +267,17 @@ export const addFunctions = (logger, node, checker, state) => {
     if (!ts.isArrowFunction(handlerNode) &&
         !ts.isFunctionExpression(handlerNode)) {
         logger.error(`• Handler for ${name} is not a function.`);
+        // Create stub metadata to prevent "function not found" errors in wirings
+        state.functions.meta[pikkuFuncName] = {
+            pikkuFuncName,
+            name,
+            services: { optimized: false, services: [] },
+            inputSchemaName: null,
+            outputSchemaName: null,
+            inputs: [],
+            outputs: [],
+            middleware: undefined,
+        };
         return;
     }
     const services = {
@@ -324,6 +369,8 @@ export const addFunctions = (logger, node, checker, state) => {
                 path: node.getSourceFile().fileName,
                 exportedName,
             });
+            // Track exposed RPC function for service aggregation
+            state.serviceAggregation.usedFunctions.add(pikkuFuncName);
         }
         // We add it to internal meta to allow autocomplete for everything
         state.rpc.internalMeta[name] = pikkuFuncName;

package/dist/add/add-http-route.js

@@ -1,11 +1,13 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from '../utils/get-property-value.js';
+import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
 import { pathToRegexp } from 'path-to-regexp';
-import { PikkuWiringTypes } from '@pikku/core';
 import { extractFunctionName } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
-import { matchesFilters } from '../utils/filter-utils.js';
 import { resolveHTTPMiddlewareFromObject } from '../utils/middleware.js';
+import { resolveHTTPPermissionsFromObject } from '../utils/permissions.js';
+import { extractWireNames } from '../utils/post-process.js';
+import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.js';
+import { ErrorCode } from '../error-codes.js';
 /**
  * Populate metaInputTypes for a given route based on method, input type,
  * query and params. Returns undefined (we only mutate metaTypes).
@@ -46,23 +48,21 @@ export const addHTTPRoute = (logger, node, checker, state, options) => {
     const params = keys.filter((k) => k.type === 'param').map((k) => k.name);
     const method = getPropertyValue(obj, 'method')?.toLowerCase() || 'get';
     const docs = getPropertyValue(obj, 'docs') || undefined;
-    const tags = getPropertyValue(obj, 'tags') || undefined;
+    const tags = getPropertyTags(obj, 'HTTP route', route, logger);
     const query = getPropertyValue(obj, 'query') || [];
-    const filePath = node.getSourceFile().fileName;
-    if (!matchesFilters(options.filters || {}, { tags }, { type: PikkuWiringTypes.http, name: route, filePath }, logger)) {
-        return;
-    }
-    // --- find the referenced function ---
+    // --- find the referenced function name first for filtering ---
     const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
     if (!funcInitializer) {
-        console.error(`• No valid 'func' property for route '${route}'.`);
+        logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for route '${route}'.`);
         return;
     }
-    const funcName = extractFunctionName(funcInitializer, checker).pikkuFuncName;
+    const funcName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
+    // Ensure function metadata exists (creates stub for inline functions)
+    ensureFunctionMetadata(state, funcName, route);
     // lookup existing function metadata
     const fnMeta = state.functions.meta[funcName];
     if (!fnMeta) {
-        console.error(`• No function metadata found for '${funcName}'.`);
+        logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for '${funcName}'.`);
         return;
     }
     const input = fnMeta.inputs?.[0] || null;
@@ -70,6 +70,12 @@ export const addHTTPRoute = (logger, node, checker, state, options) => {
     const inputTypes = getInputTypes(state.http.metaInputTypes, method, input, query, params);
     // --- resolve middleware ---
     const middleware = resolveHTTPMiddlewareFromObject(state, route, obj, tags, checker);
+    // --- resolve permissions ---
+    const permissions = resolveHTTPPermissionsFromObject(state, route, obj, tags, checker);
+    // --- track used functions/middleware/permissions for service aggregation ---
+    state.serviceAggregation.usedFunctions.add(funcName);
+    extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
+    extractWireNames(permissions).forEach((name) => state.serviceAggregation.usedPermissions.add(name));
     // --- record route ---
     state.http.files.add(node.getSourceFile().fileName);
     state.http.meta[method][route] = {
@@ -82,5 +88,6 @@ export const addHTTPRoute = (logger, node, checker, state, options) => {
         docs,
         tags,
         middleware,
+        permissions,
     };
 };

package/dist/add/add-mcp-prompt.js

@@ -1,10 +1,12 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from '../utils/get-property-value.js';
-import { PikkuWiringTypes } from '@pikku/core';
+import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
+import { extractWireNames } from '../utils/post-process.js';
+import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.js';
 import { extractFunctionName } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
-import { matchesFilters } from '../utils/filter-utils.js';
 import { resolveMiddleware } from '../utils/middleware.js';
+import { resolvePermissions } from '../utils/permissions.js';
+import { ErrorCode } from '../error-codes.js';
 export const addMCPPrompt = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
         return;
@@ -23,35 +25,39 @@ export const addMCPPrompt = (logger, node, checker, state, options) => {
         const obj = firstArg;
         const nameValue = getPropertyValue(obj, 'name');
         const descriptionValue = getPropertyValue(obj, 'description');
-        const tags = getPropertyValue(obj, 'tags') || undefined;
+        const tags = getPropertyTags(obj, 'MCP prompt', nameValue, logger);
         const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
         if (!funcInitializer) {
-            console.error(`• No valid 'func' property for MCP prompt '${nameValue}'.`);
+            logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for MCP prompt '${nameValue}'.`);
             return;
         }
-        const pikkuFuncName = extractFunctionName(funcInitializer, checker).pikkuFuncName;
+        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
+        // Ensure function metadata exists (creates stub for inline functions)
+        ensureFunctionMetadata(state, pikkuFuncName, nameValue || undefined);
         if (!nameValue) {
-            console.error(`• MCP prompt is missing the required 'name' property.`);
+            logger.critical(ErrorCode.MISSING_NAME, "MCP prompt is missing the required 'name' property.");
             return;
         }
         if (!descriptionValue) {
-            console.error(`• MCP prompt '${nameValue}' is missing a description.`);
-            return;
-        }
-        const filePath = node.getSourceFile().fileName;
-        if (!matchesFilters(options.filters || {}, { tags }, { type: PikkuWiringTypes.mcp, name: nameValue, filePath }, logger)) {
+            logger.critical(ErrorCode.MISSING_DESCRIPTION, `MCP prompt '${nameValue}' is missing a description.`);
             return;
         }
         // lookup existing function metadata
         const fnMeta = state.functions.meta[pikkuFuncName];
         if (!fnMeta) {
-            console.error(`• No function metadata found for '${pikkuFuncName}'.`);
+            logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for '${pikkuFuncName}'.`);
             return;
         }
         const inputSchema = fnMeta.inputs?.[0] || null;
         const outputSchema = fnMeta.outputs?.[0] || null;
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
+        // --- resolve permissions ---
+        const permissions = resolvePermissions(state, obj, tags, checker);
+        // --- track used functions/middleware/permissions for service aggregation ---
+        state.serviceAggregation.usedFunctions.add(pikkuFuncName);
+        extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
+        extractWireNames(permissions).forEach((name) => state.serviceAggregation.usedPermissions.add(name));
         state.mcpEndpoints.files.add(node.getSourceFile().fileName);
         state.mcpEndpoints.promptsMeta[nameValue] = {
             pikkuFuncName,
@@ -62,6 +68,7 @@ export const addMCPPrompt = (logger, node, checker, state, options) => {
             outputSchema,
             arguments: [], // Will be populated by CLI during serialization
             middleware,
+            permissions,
         };
     }
 };

package/dist/add/add-mcp-resource.js

@@ -1,10 +1,12 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from '../utils/get-property-value.js';
-import { PikkuWiringTypes } from '@pikku/core';
+import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
+import { extractWireNames } from '../utils/post-process.js';
+import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.js';
 import { extractFunctionName } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
-import { matchesFilters } from '../utils/filter-utils.js';
 import { resolveMiddleware } from '../utils/middleware.js';
+import { resolvePermissions } from '../utils/permissions.js';
+import { ErrorCode } from '../error-codes.js';
 export const addMCPResource = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
         return;
@@ -25,39 +27,46 @@ export const addMCPResource = (logger, node, checker, state, options) => {
         const titleValue = getPropertyValue(obj, 'title');
         const descriptionValue = getPropertyValue(obj, 'description');
         const streamingValue = getPropertyValue(obj, 'streaming');
-        const tags = getPropertyValue(obj, 'tags') || undefined;
+        const tags = getPropertyTags(obj, 'MCP resource', uriValue, logger);
+        if (streamingValue === true) {
+            logger.warn(`MCP resource '${uriValue}' has streaming enabled, but streaming is not yet supported.`);
+        }
         const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
         if (!funcInitializer) {
-            console.error(`• No valid 'func' property for MCP resource '${uriValue}'.`);
+            logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for MCP resource '${uriValue}'.`);
             return;
         }
-        const pikkuFuncName = extractFunctionName(funcInitializer, checker).pikkuFuncName;
+        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
+        // Ensure function metadata exists (creates stub for inline functions)
+        ensureFunctionMetadata(state, pikkuFuncName, uriValue || undefined);
         if (!uriValue) {
-            console.error(`• MCP resource is missing the required 'uri' property.`);
+            logger.critical(ErrorCode.MISSING_URI, "MCP resource is missing the required 'uri' property.");
             return;
         }
         if (!titleValue) {
-            console.error(`• MCP resource '${uriValue}' is missing the required 'title' property.`);
+            logger.critical(ErrorCode.MISSING_TITLE, `MCP resource '${uriValue}' is missing the required 'title' property.`);
             return;
         }
         if (!descriptionValue) {
-            console.error(`• MCP resource '${uriValue}' is missing a description.`);
-            return;
-        }
-        const filePath = node.getSourceFile().fileName;
-        if (!matchesFilters(options.filters || {}, { tags }, { type: PikkuWiringTypes.mcp, name: uriValue, filePath }, logger)) {
+            logger.critical(ErrorCode.MISSING_DESCRIPTION, `MCP resource '${uriValue}' is missing a description.`);
             return;
         }
         // lookup existing function metadata
         const fnMeta = state.functions.meta[pikkuFuncName];
         if (!fnMeta) {
-            console.error(`• No function metadata found for '${pikkuFuncName}'.`);
+            logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for '${pikkuFuncName}'.`);
             return;
         }
         const inputSchema = fnMeta.inputs?.[0] || null;
         const outputSchema = fnMeta.outputs?.[0] || null;
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
+        // --- resolve permissions ---
+        const permissions = resolvePermissions(state, obj, tags, checker);
+        // --- track used functions/middleware/permissions for service aggregation ---
+        state.serviceAggregation.usedFunctions.add(pikkuFuncName);
+        extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
+        extractWireNames(permissions).forEach((name) => state.serviceAggregation.usedPermissions.add(name));
         state.mcpEndpoints.files.add(node.getSourceFile().fileName);
         state.mcpEndpoints.resourcesMeta[uriValue] = {
             pikkuFuncName,
@@ -69,6 +78,7 @@ export const addMCPResource = (logger, node, checker, state, options) => {
             inputSchema,
             outputSchema,
             middleware,
+            permissions,
         };
     }
 };

package/dist/add/add-mcp-tool.js

@@ -1,10 +1,12 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from '../utils/get-property-value.js';
-import { PikkuWiringTypes } from '@pikku/core';
+import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
+import { extractWireNames } from '../utils/post-process.js';
+import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.js';
 import { extractFunctionName } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
-import { matchesFilters } from '../utils/filter-utils.js';
 import { resolveMiddleware } from '../utils/middleware.js';
+import { resolvePermissions } from '../utils/permissions.js';
+import { ErrorCode } from '../error-codes.js';
 export const addMCPTool = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
         return;
@@ -25,35 +27,42 @@ export const addMCPTool = (logger, node, checker, state, options) => {
         const titleValue = getPropertyValue(obj, 'title');
         const descriptionValue = getPropertyValue(obj, 'description');
         const streamingValue = getPropertyValue(obj, 'streaming');
-        const tags = getPropertyValue(obj, 'tags') || undefined;
+        const tags = getPropertyTags(obj, 'MCP tool', nameValue, logger);
+        if (streamingValue === true) {
+            logger.warn(`MCP tool '${nameValue}' has streaming enabled, but streaming is not yet supported.`);
+        }
         const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
         if (!funcInitializer) {
-            console.error(`• No valid 'func' property for MCP tool '${nameValue}'.`);
+            logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for MCP tool '${nameValue}'.`);
             return;
         }
-        const pikkuFuncName = extractFunctionName(funcInitializer, checker).pikkuFuncName;
+        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
+        // Ensure function metadata exists (creates stub for inline functions)
+        ensureFunctionMetadata(state, pikkuFuncName, nameValue || undefined);
         if (!nameValue) {
-            console.error(`• MCP tool is missing the required 'name' property.`);
+            logger.critical(ErrorCode.MISSING_NAME, "MCP tool is missing the required 'name' property.");
             return;
         }
         if (!descriptionValue) {
-            console.error(`• MCP tool '${nameValue}' is missing a description.`);
-            return;
-        }
-        const filePath = node.getSourceFile().fileName;
-        if (!matchesFilters(options.filters || {}, { tags }, { type: PikkuWiringTypes.mcp, name: nameValue, filePath }, logger)) {
+            logger.critical(ErrorCode.MISSING_DESCRIPTION, `MCP tool '${nameValue}' is missing a description.`);
             return;
         }
         // lookup existing function metadata
         const fnMeta = state.functions.meta[pikkuFuncName];
         if (!fnMeta) {
-            console.error(`• No function metadata found for '${pikkuFuncName}'.`);
+            logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for '${pikkuFuncName}'.`);
             return;
         }
         const inputSchema = fnMeta.inputs?.[0] || null;
         const outputSchema = fnMeta.outputs?.[0] || null;
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
+        // --- resolve permissions ---
+        const permissions = resolvePermissions(state, obj, tags, checker);
+        // --- track used functions/middleware/permissions for service aggregation ---
+        state.serviceAggregation.usedFunctions.add(pikkuFuncName);
+        extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
+        extractWireNames(permissions).forEach((name) => state.serviceAggregation.usedPermissions.add(name));
         state.mcpEndpoints.files.add(node.getSourceFile().fileName);
         state.mcpEndpoints.toolsMeta[nameValue] = {
             pikkuFuncName,
@@ -65,6 +74,7 @@ export const addMCPTool = (logger, node, checker, state, options) => {
             inputSchema,
             outputSchema,
             middleware,
+            permissions,
         };
     }
 };