@pikku/inspector 0.11.1 → 0.12.0

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

@@ -1,18 +1,67 @@
 import * as ts from 'typescript';
 import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
 import { pathToRegexp } from 'path-to-regexp';
-import { extractFunctionName } from '../utils/extract-function-name.js';
-import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
+import { extractFunctionName, makeContextBasedId, } from '../utils/extract-function-name.js';
+import { getPropertyAssignmentInitializer, extractTypeKeys, } from '../utils/type-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';
+import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js';
+/**
+ * Extract header schema reference from headers property
+ */
+const extractHeadersSchema = (obj, routeName, method, state, checker, logger) => {
+    const headersNode = getPropertyAssignmentInitializer(obj, 'headers', true, checker);
+    if (!headersNode || !ts.isIdentifier(headersNode))
+        return undefined;
+    // Resolve the schema reference
+    const symbol = checker.getSymbolAtLocation(headersNode);
+    if (!symbol)
+        return undefined;
+    const decl = symbol.valueDeclaration || symbol.declarations?.[0];
+    if (!decl)
+        return undefined;
+    let sourceFile;
+    if (ts.isImportSpecifier(decl)) {
+        const aliasedSymbol = checker.getAliasedSymbol(symbol);
+        if (aliasedSymbol) {
+            const aliasedDecl = aliasedSymbol.valueDeclaration || aliasedSymbol.declarations?.[0];
+            if (aliasedDecl) {
+                sourceFile = aliasedDecl.getSourceFile().fileName;
+            }
+            else {
+                return undefined;
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
+    else {
+        sourceFile = decl.getSourceFile().fileName;
+    }
+    const vendor = detectSchemaVendorOrError(headersNode, checker, logger, `Route '${routeName}' header`, sourceFile);
+    if (!vendor)
+        return undefined;
+    // Create a sanitized schema name from route and method to avoid collisions
+    const sanitizedRoute = routeName
+        .replace(/[^a-zA-Z0-9]/g, '_')
+        .replace(/^_+|_+$/g, '');
+    const schemaName = `${method.toUpperCase()}_${sanitizedRoute}_Headers`;
+    state.schemaLookup.set(schemaName, {
+        variableName: headersNode.text,
+        sourceFile,
+        vendor,
+    });
+    return schemaName;
+};
 /**
  * Populate metaInputTypes for a given route based on method, input type,
- * query and params. Returns undefined (we only mutate metaTypes).
+ * query and params.
  */
-export const getInputTypes = (metaTypes, methodType, inputType, queryValues, paramsValues) => {
+const computeInputTypes = (metaTypes, methodType, inputType, queryValues, paramsValues) => {
     if (!inputType)
         return;
     metaTypes.set(inputType, {
@@ -22,73 +71,133 @@ export const getInputTypes = (metaTypes, methodType, inputType, queryValues, par
             ? [...new Set([...queryValues, ...paramsValues])]
             : [],
     });
-    return;
 };
 /**
- * Simplified wireHTTP: re-uses function metadata from state.functions.meta
- * instead of re-inferring types here.
+ * Shared function to register an HTTP route in the inspector state.
+ * Used by both wireHTTP and wireHTTPRoutes.
  */
-export const addHTTPRoute = (logger, node, checker, state, options) => {
-    // only look at calls
-    if (!ts.isCallExpression(node))
+export function registerHTTPRoute({ obj, state, checker, logger, sourceFile, basePath = '', inheritedTags = [], }) {
+    // Extract route path
+    const routePath = getPropertyValue(obj, 'route');
+    if (!routePath)
         return;
-    const { expression, arguments: args } = node;
-    if (!ts.isIdentifier(expression) || expression.text !== 'wireHTTP')
-        return;
-    // must pass an object literal
-    const firstArg = args[0];
-    if (!firstArg || !ts.isObjectLiteralExpression(firstArg))
+    const method = (getPropertyValue(obj, 'method') || 'get').toLowerCase();
+    const fullRoute = basePath + routePath;
+    // Extract params from route path
+    let params = [];
+    try {
+        const keys = pathToRegexp(fullRoute).keys;
+        params = keys.filter((k) => k.type === 'param').map((k) => k.name);
+    }
+    catch (e) {
+        logger.error(`Failed to parse route '${fullRoute}': ${e instanceof Error ? e.message : e}`);
         return;
-    const obj = firstArg;
-    // --- extract HTTP metadata ---
-    const route = getPropertyValue(obj, 'route');
-    if (!route)
+    }
+    // Get common metadata
+    const { disabled, title, tags: routeTags, summary, description, errors, } = getCommonWireMetaData(obj, 'HTTP route', fullRoute, logger);
+    if (disabled)
         return;
-    const keys = pathToRegexp(route).keys;
-    const params = keys.filter((k) => k.type === 'param').map((k) => k.name);
-    const method = getPropertyValue(obj, 'method')?.toLowerCase() || 'get';
-    const { tags, summary, description, errors } = getCommonWireMetaData(obj, 'HTTP route', route, logger);
+    // Merge inherited tags with route tags
+    const tags = [...inheritedTags, ...(routeTags || [])];
     const query = getPropertyValue(obj, 'query') || [];
-    // --- find the referenced function name first for filtering ---
+    // Get function reference
     const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
     if (!funcInitializer) {
-        logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for route '${route}'.`);
+        logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for route '${fullRoute}'.`);
         return;
     }
-    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 extracted = extractFunctionName(funcInitializer, checker, state.rootDir);
+    let funcName = extracted.pikkuFuncId;
+    if (funcName.startsWith('__temp_')) {
+        funcName = makeContextBasedId('http', method, fullRoute);
+    }
+    ensureFunctionMetadata(state, funcName, fullRoute, funcInitializer, checker, extracted.isHelper);
+    // Lookup existing function metadata
     const fnMeta = state.functions.meta[funcName];
     if (!fnMeta) {
         logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for '${funcName}'.`);
         return;
     }
     const input = fnMeta.inputs?.[0] || null;
-    // --- compute inputTypes (body/query/params) ---
-    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 ---
+    // Validate that route params and query params exist in function input type
+    if (params.length > 0 || query.length > 0) {
+        const inputTypes = state.typesLookup.get(funcName);
+        if (inputTypes && inputTypes.length > 0) {
+            const inputKeys = extractTypeKeys(inputTypes[0]);
+            // Check path params
+            if (params.length > 0) {
+                const missingParams = params.filter((p) => !inputKeys.includes(p));
+                if (missingParams.length > 0) {
+                    logger.critical(ErrorCode.ROUTE_PARAM_MISMATCH, `Route '${fullRoute}' has path parameter(s) [${missingParams.join(', ')}] ` +
+                        `not found in function '${funcName}' input type. ` +
+                        `Input type has: [${inputKeys.join(', ')}]`);
+                    return;
+                }
+            }
+            // Check query params
+            if (query.length > 0) {
+                const missingQuery = query.filter((q) => !inputKeys.includes(q));
+                if (missingQuery.length > 0) {
+                    logger.critical(ErrorCode.ROUTE_QUERY_MISMATCH, `Route '${fullRoute}' has query parameter(s) [${missingQuery.join(', ')}] ` +
+                        `not found in function '${funcName}' input type. ` +
+                        `Input type has: [${inputKeys.join(', ')}]`);
+                    return;
+                }
+            }
+        }
+    }
+    // Compute inputTypes (body/query/params)
+    computeInputTypes(state.http.metaInputTypes, method, input, query, params);
+    // Resolve middleware
+    const middleware = resolveHTTPMiddlewareFromObject(state, fullRoute, obj, tags, checker);
+    // Resolve permissions
+    const permissions = resolveHTTPPermissionsFromObject(state, fullRoute, 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] = {
-        pikkuFuncName: funcName,
-        route,
+    // Check for SSE
+    const sse = getPropertyValue(obj, 'sse') === true;
+    // Extract header schema
+    const headersSchemaName = extractHeadersSchema(obj, fullRoute, method, state, checker, logger);
+    // Record route
+    state.http.files.add(sourceFile.fileName);
+    state.http.meta[method][fullRoute] = {
+        pikkuFuncId: funcName,
+        route: fullRoute,
         method: method,
         params: params.length > 0 ? params : undefined,
         query: query.length > 0 ? query : undefined,
-        inputTypes,
+        inputTypes: undefined,
+        title,
         summary,
         description,
         errors,
-        tags,
+        tags: tags.length > 0 ? tags : undefined,
         middleware,
         permissions,
+        sse: sse ? true : undefined,
+        headersSchemaName,
+        groupBasePath: basePath || undefined,
     };
+}
+/**
+ * Process wireHTTP calls
+ */
+export const addHTTPRoute = (logger, node, checker, state, _options) => {
+    if (!ts.isCallExpression(node))
+        return;
+    const { expression, arguments: args } = node;
+    if (!ts.isIdentifier(expression) || expression.text !== 'wireHTTP')
+        return;
+    const firstArg = args[0];
+    if (!firstArg || !ts.isObjectLiteralExpression(firstArg))
+        return;
+    registerHTTPRoute({
+        obj: firstArg,
+        state,
+        checker,
+        logger,
+        sourceFile: node.getSourceFile(),
+    });
 };

package/dist/add/add-http-routes.d.ts

@@ -0,0 +1,5 @@
+import { AddWiring } from '../types.js';
+/**
+ * Process wireHTTPRoutes calls
+ */
+export declare const addHTTPRoutes: AddWiring;

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

@@ -0,0 +1,159 @@
+import * as ts from 'typescript';
+import { getPropertyValue } from '../utils/get-property-value.js';
+import { registerHTTPRoute } from './add-http-route.js';
+import { resolveIdentifier } from '../utils/resolve-identifier.js';
+/**
+ * Process wireHTTPRoutes calls
+ */
+export const addHTTPRoutes = (logger, node, checker, state, _options) => {
+    if (!ts.isCallExpression(node))
+        return;
+    const { expression, arguments: args } = node;
+    if (!ts.isIdentifier(expression) || expression.text !== 'wireHTTPRoutes')
+        return;
+    const firstArg = args[0];
+    if (!firstArg || !ts.isObjectLiteralExpression(firstArg))
+        return;
+    // Extract group config
+    const groupConfig = extractGroupConfig(firstArg);
+    // Get routes property
+    const routesProp = getPropertyAssignment(firstArg, 'routes');
+    if (!routesProp)
+        return;
+    // Process routes recursively
+    processRoutes(routesProp.initializer, groupConfig, state, checker, logger, node.getSourceFile());
+};
+/**
+ * Get a property assignment from an object literal
+ */
+function getPropertyAssignment(obj, propName) {
+    for (const prop of obj.properties) {
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === propName) {
+            return prop;
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract group configuration from an object literal
+ */
+function extractGroupConfig(obj) {
+    const basePath = getPropertyValue(obj, 'basePath') || '';
+    const tags = getPropertyValue(obj, 'tags') || [];
+    const auth = getPropertyValue(obj, 'auth');
+    return {
+        basePath,
+        tags,
+        auth: auth === true ? true : auth === false ? false : undefined,
+    };
+}
+/**
+ * Merge two group configs following cascading rules
+ */
+function mergeConfigs(parent, child) {
+    return {
+        basePath: parent.basePath + child.basePath,
+        tags: [...parent.tags, ...child.tags],
+        auth: child.auth ?? parent.auth,
+    };
+}
+/**
+ * Check if a value is a route config (has method, func, and route)
+ */
+function isRouteConfig(obj) {
+    let hasMethod = false;
+    let hasFunc = false;
+    let hasRoute = false;
+    for (const prop of obj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+            if (prop.name.text === 'method')
+                hasMethod = true;
+            if (prop.name.text === 'func')
+                hasFunc = true;
+            if (prop.name.text === 'route')
+                hasRoute = true;
+        }
+    }
+    return hasMethod && hasFunc && hasRoute;
+}
+/**
+ * Check if a value is a route contract (has routes property but no method/func)
+ */
+function isRouteContract(obj) {
+    let hasRoutes = false;
+    let hasMethod = false;
+    let hasFunc = false;
+    for (const prop of obj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+            if (prop.name.text === 'routes')
+                hasRoutes = true;
+            if (prop.name.text === 'method')
+                hasMethod = true;
+            if (prop.name.text === 'func')
+                hasFunc = true;
+        }
+    }
+    return hasRoutes && !hasMethod && !hasFunc;
+}
+/**
+ * Recursively process routes - handles nested maps, contracts, and identifiers
+ */
+function processRoutes(node, parentConfig, state, checker, logger, sourceFile) {
+    // Handle array of routes
+    if (ts.isArrayLiteralExpression(node)) {
+        for (const element of node.elements) {
+            if (ts.isObjectLiteralExpression(element) && isRouteConfig(element)) {
+                processRoute(element, parentConfig, state, checker, logger, sourceFile);
+            }
+        }
+        return;
+    }
+    // Handle object literal
+    if (ts.isObjectLiteralExpression(node)) {
+        // Check if this is a route config
+        if (isRouteConfig(node)) {
+            processRoute(node, parentConfig, state, checker, logger, sourceFile);
+            return;
+        }
+        // Check if this is a route contract
+        if (isRouteContract(node)) {
+            const contractConfig = extractGroupConfig(node);
+            const mergedConfig = mergeConfigs(parentConfig, contractConfig);
+            const routesProp = getPropertyAssignment(node, 'routes');
+            if (routesProp) {
+                processRoutes(routesProp.initializer, mergedConfig, state, checker, logger, sourceFile);
+            }
+            return;
+        }
+        // Otherwise it's a nested map - process each property
+        for (const prop of node.properties) {
+            if (ts.isPropertyAssignment(prop)) {
+                processRoutes(prop.initializer, parentConfig, state, checker, logger, sourceFile);
+            }
+        }
+        return;
+    }
+    // Handle identifier - resolve to its definition
+    if (ts.isIdentifier(node)) {
+        const resolved = resolveIdentifier(node, checker, ['defineHTTPRoutes']);
+        if (resolved) {
+            processRoutes(resolved, parentConfig, state, checker, logger, sourceFile);
+        }
+    }
+}
+/**
+ * Register a single route using the shared registerHTTPRoute function
+ */
+function processRoute(obj, groupConfig, state, checker, logger, sourceFile) {
+    registerHTTPRoute({
+        obj,
+        state,
+        checker,
+        logger,
+        sourceFile,
+        basePath: groupConfig.basePath,
+        inheritedTags: groupConfig.tags,
+    });
+}

package/dist/add/add-keyed-wiring.d.ts

@@ -0,0 +1,12 @@
+import { AddWiring, InspectorState } from '../types.js';
+export interface KeyedWiringConfig {
+    functionName: string;
+    idField: string;
+    label: string;
+    schemaPrefix: string;
+    getState: (state: InspectorState) => {
+        definitions: any[];
+        files: Set<string>;
+    };
+}
+export declare const createAddKeyedWiring: (config: KeyedWiringConfig) => AddWiring;

package/dist/add/add-keyed-wiring.js

@@ -0,0 +1,97 @@
+import * as ts from 'typescript';
+import { getPropertyValue } from '../utils/get-property-value.js';
+import { ErrorCode } from '../error-codes.js';
+import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js';
+export const createAddKeyedWiring = (config) => {
+    return (logger, node, checker, state, _options) => {
+        if (!ts.isCallExpression(node)) {
+            return;
+        }
+        const args = node.arguments;
+        const firstArg = args[0];
+        const expression = node.expression;
+        if (!ts.isIdentifier(expression) ||
+            expression.text !== config.functionName) {
+            return;
+        }
+        if (!firstArg) {
+            return;
+        }
+        if (ts.isObjectLiteralExpression(firstArg)) {
+            const obj = firstArg;
+            const nameValue = getPropertyValue(obj, 'name');
+            const displayNameValue = getPropertyValue(obj, 'displayName');
+            const descriptionValue = getPropertyValue(obj, 'description');
+            const idValue = getPropertyValue(obj, config.idField);
+            let schemaVariableName = null;
+            let schemaSourceFile = null;
+            let schemaIdentifier = null;
+            for (const prop of obj.properties) {
+                if (ts.isPropertyAssignment(prop) &&
+                    ts.isIdentifier(prop.name) &&
+                    prop.name.text === 'schema') {
+                    if (ts.isIdentifier(prop.initializer)) {
+                        schemaVariableName = prop.initializer.text;
+                        schemaIdentifier = prop.initializer;
+                        const symbol = checker.getSymbolAtLocation(prop.initializer);
+                        if (symbol) {
+                            const decl = symbol.valueDeclaration || symbol.declarations?.[0];
+                            if (decl) {
+                                if (ts.isImportSpecifier(decl)) {
+                                    const aliasedSymbol = checker.getAliasedSymbol(symbol);
+                                    if (aliasedSymbol) {
+                                        const aliasedDecl = aliasedSymbol.valueDeclaration ||
+                                            aliasedSymbol.declarations?.[0];
+                                        if (aliasedDecl) {
+                                            schemaSourceFile = aliasedDecl.getSourceFile().fileName;
+                                        }
+                                    }
+                                }
+                                else {
+                                    schemaSourceFile = decl.getSourceFile().fileName;
+                                }
+                            }
+                        }
+                    }
+                    break;
+                }
+            }
+            if (!nameValue) {
+                logger.critical(ErrorCode.MISSING_NAME, `${config.label} is missing the required 'name' property.`);
+                return;
+            }
+            if (!displayNameValue) {
+                logger.critical(ErrorCode.MISSING_NAME, `${config.label} '${nameValue}' is missing the required 'displayName' property.`);
+                return;
+            }
+            if (!idValue) {
+                logger.critical(ErrorCode.MISSING_NAME, `${config.label} '${nameValue}' is missing the required '${config.idField}' property.`);
+                return;
+            }
+            if (!schemaVariableName || !schemaSourceFile || !schemaIdentifier) {
+                logger.critical(ErrorCode.MISSING_NAME, `${config.label} '${nameValue}' is missing the required 'schema' property or schema is not a variable reference.`);
+                return;
+            }
+            const sourceFile = node.getSourceFile().fileName;
+            const wiringState = config.getState(state);
+            wiringState.files.add(sourceFile);
+            const vendor = detectSchemaVendorOrError(schemaIdentifier, checker, logger, `${config.label} '${nameValue}'`, schemaSourceFile);
+            if (!vendor)
+                return;
+            const schemaLookupName = `${config.schemaPrefix}_${nameValue}`;
+            state.schemaLookup.set(schemaLookupName, {
+                variableName: schemaVariableName,
+                sourceFile: schemaSourceFile,
+                vendor,
+            });
+            wiringState.definitions.push({
+                name: nameValue,
+                displayName: displayNameValue,
+                description: descriptionValue || undefined,
+                [config.idField]: idValue,
+                schema: schemaLookupName,
+                sourceFile,
+            });
+        }
+    };
+};

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

@@ -2,7 +2,7 @@ import * as ts from 'typescript';
 import { getPropertyValue, getCommonWireMetaData, } 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 { extractFunctionName, makeContextBasedId, } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
 import { resolveMiddleware } from '../utils/middleware.js';
 import { resolvePermissions } from '../utils/permissions.js';
@@ -24,15 +24,20 @@ export const addMCPPrompt = (logger, node, checker, state, options) => {
     if (ts.isObjectLiteralExpression(firstArg)) {
         const obj = firstArg;
         const nameValue = getPropertyValue(obj, 'name');
-        const { tags, summary, description, errors } = getCommonWireMetaData(obj, 'MCP prompt', nameValue, logger);
+        const { disabled, tags, summary, description, errors } = getCommonWireMetaData(obj, 'MCP prompt', nameValue, logger);
+        if (disabled)
+            return;
         const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
         if (!funcInitializer) {
             logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for MCP prompt '${nameValue}'.`);
             return;
         }
-        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
-        // Ensure function metadata exists (creates stub for inline functions)
-        ensureFunctionMetadata(state, pikkuFuncName, nameValue || undefined);
+        const extracted = extractFunctionName(funcInitializer, checker, state.rootDir);
+        let pikkuFuncId = extracted.pikkuFuncId;
+        if (pikkuFuncId.startsWith('__temp_') && nameValue) {
+            pikkuFuncId = makeContextBasedId('mcp', 'prompt', nameValue);
+        }
+        ensureFunctionMetadata(state, pikkuFuncId, nameValue || undefined, funcInitializer, checker, extracted.isHelper);
         if (!nameValue) {
             logger.critical(ErrorCode.MISSING_NAME, "MCP prompt is missing the required 'name' property.");
             return;
@@ -42,9 +47,9 @@ export const addMCPPrompt = (logger, node, checker, state, options) => {
             return;
         }
         // lookup existing function metadata
-        const fnMeta = state.functions.meta[pikkuFuncName];
+        const fnMeta = state.functions.meta[pikkuFuncId];
         if (!fnMeta) {
-            logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for '${pikkuFuncName}'.`);
+            logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for '${pikkuFuncId}'.`);
             return;
         }
         const inputSchema = fnMeta.inputs?.[0] || null;
@@ -54,12 +59,12 @@ export const addMCPPrompt = (logger, node, checker, state, options) => {
         // --- resolve permissions ---
         const permissions = resolvePermissions(state, obj, tags, checker);
         // --- track used functions/middleware/permissions for service aggregation ---
-        state.serviceAggregation.usedFunctions.add(pikkuFuncName);
+        state.serviceAggregation.usedFunctions.add(pikkuFuncId);
         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,
+            pikkuFuncId,
             name: nameValue,
             description,
             summary,

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

@@ -2,7 +2,7 @@ import * as ts from 'typescript';
 import { getPropertyValue, getCommonWireMetaData, } 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 { extractFunctionName, makeContextBasedId, } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
 import { resolveMiddleware } from '../utils/middleware.js';
 import { resolvePermissions } from '../utils/permissions.js';
@@ -25,7 +25,9 @@ export const addMCPResource = (logger, node, checker, state, options) => {
         const obj = firstArg;
         const uriValue = getPropertyValue(obj, 'uri');
         const titleValue = getPropertyValue(obj, 'title');
-        const { tags, summary, description, errors } = getCommonWireMetaData(obj, 'MCP resource', uriValue, logger);
+        const { disabled, tags, summary, description, errors } = getCommonWireMetaData(obj, 'MCP resource', uriValue, logger);
+        if (disabled)
+            return;
         const streamingValue = getPropertyValue(obj, 'streaming');
         if (streamingValue === true) {
             logger.warn(`MCP resource '${uriValue}' has streaming enabled, but streaming is not yet supported.`);
@@ -35,9 +37,12 @@ export const addMCPResource = (logger, node, checker, state, options) => {
             logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for MCP resource '${uriValue}'.`);
             return;
         }
-        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
-        // Ensure function metadata exists (creates stub for inline functions)
-        ensureFunctionMetadata(state, pikkuFuncName, uriValue || undefined);
+        const extracted = extractFunctionName(funcInitializer, checker, state.rootDir);
+        let pikkuFuncId = extracted.pikkuFuncId;
+        if (pikkuFuncId.startsWith('__temp_') && uriValue) {
+            pikkuFuncId = makeContextBasedId('mcp', 'resource', uriValue);
+        }
+        ensureFunctionMetadata(state, pikkuFuncId, uriValue || undefined, funcInitializer, checker, extracted.isHelper);
         if (!uriValue) {
             logger.critical(ErrorCode.MISSING_URI, "MCP resource is missing the required 'uri' property.");
             return;
@@ -51,9 +56,9 @@ export const addMCPResource = (logger, node, checker, state, options) => {
             return;
         }
         // lookup existing function metadata
-        const fnMeta = state.functions.meta[pikkuFuncName];
+        const fnMeta = state.functions.meta[pikkuFuncId];
         if (!fnMeta) {
-            logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for '${pikkuFuncName}'.`);
+            logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for '${pikkuFuncId}'.`);
             return;
         }
         const inputSchema = fnMeta.inputs?.[0] || null;
@@ -63,12 +68,12 @@ export const addMCPResource = (logger, node, checker, state, options) => {
         // --- resolve permissions ---
         const permissions = resolvePermissions(state, obj, tags, checker);
         // --- track used functions/middleware/permissions for service aggregation ---
-        state.serviceAggregation.usedFunctions.add(pikkuFuncName);
+        state.serviceAggregation.usedFunctions.add(pikkuFuncId);
         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,
+            pikkuFuncId,
             uri: uriValue,
             title: titleValue,
             description,

package/dist/add/add-middleware.d.ts

@@ -1,5 +1,2 @@
-import { AddWiring } from '../types.js';
-/**
- * Inspect pikkuMiddleware calls, addMiddleware calls, and addHTTPMiddleware calls
- */
+import type { AddWiring } from '../types.js';
 export declare const addMiddleware: AddWiring;