@pikku/inspector 0.12.2 → 0.12.4

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 ## 0.12.0
 
+## 0.12.4
+
+### Patch Changes
+
+- 5866b66: Add critical error (PKU490) when Zod schemas and wiring calls (wireHTTPRoutes, addPermission, addHTTPMiddleware) coexist in the same file. The CLI uses tsImport to extract Zod schemas at runtime, which executes all top-level code — wiring side-effects crash in this context because pikku state metadata doesn't exist. Schemas and wirings must be in separate files.
+- e412b4d: Optimize CLI codegen performance: 12x faster `pikku all`
+
+  - Reuse schemas across re-inspections (skip redundant `ts-json-schema-generator` runs)
+  - Cache TS schemas to disk (`.pikku/schema-cache.json`) for cross-run reuse
+  - Pass `oldProgram` to `ts.createProgram` for incremental TS compilation
+  - Cache parsed tsconfig in schema generator between runs
+  - Auto-include direct `addPermission`/`addHTTPMiddleware` in bootstrap via side-effect imports
+  - Skip `pikkuAuth()` errors when nested inside `addPermission`/`addHTTPPermission`
+
+- Updated dependencies [e412b4d]
+- Updated dependencies [53dc8c8]
+- Updated dependencies [0a1cc51]
+- Updated dependencies [0a1cc51]
+- Updated dependencies [0a1cc51]
+- Updated dependencies [0a1cc51]
+- Updated dependencies [0a1cc51]
+- Updated dependencies [0a1cc51]
+- Updated dependencies [0a1cc51]
+- Updated dependencies [0a1cc51]
+- Updated dependencies [0a1cc51]
+- Updated dependencies [8b9b2e9]
+- Updated dependencies [8b9b2e9]
+- Updated dependencies [b973d44]
+- Updated dependencies [8b9b2e9]
+- Updated dependencies [8b9b2e9]
+  - @pikku/core@0.12.9
+
+## 0.12.3
+
+### Patch Changes
+
+- 508a796: Fix MCP server not exposing addon tools: resolve namespaced function IDs in MCP runner, load addon schemas after schema generation, and use resolveFunctionMeta for MCP JSON serialization
+- 387b2ee: Add approval description inspection, track packageName on wire metadata, and resolve addon package names in channel/RPC wirings
+- Updated dependencies [387b2ee]
+- Updated dependencies [32ed003]
+- Updated dependencies [7d369f3]
+- Updated dependencies [508a796]
+- Updated dependencies [ffe83af]
+- Updated dependencies [c7ff141]
+  - @pikku/core@0.12.3
+
 ## 0.12.2
 
 ### Patch Changes

package/dist/add/add-ai-agent.js

@@ -167,6 +167,7 @@ export const addAIAgent = (logger, node, checker, state, options) => {
         const maxStepsValue = getPropertyValue(obj, 'maxSteps');
         const temperatureValue = getPropertyValue(obj, 'temperature');
         const toolChoiceValue = getPropertyValue(obj, 'toolChoice');
+        const dynamicWorkflowsValue = getPropertyValue(obj, 'dynamicWorkflows');
         const toolsValue = resolveToolReferences(obj, checker, nameValue || '', logger);
         if (toolsValue) {
             for (const toolName of toolsValue) {
@@ -301,6 +302,9 @@ export const addAIAgent = (logger, node, checker, state, options) => {
             }),
             ...(toolsValue !== null && { tools: toolsValue }),
             ...(agentsValue !== null && { agents: agentsValue }),
+            ...(dynamicWorkflowsValue !== null && {
+                dynamicWorkflows: dynamicWorkflowsValue,
+            }),
             tags,
             inputSchema,
             outputSchema,

package/dist/add/add-approval-description.d.ts

@@ -0,0 +1,5 @@
+import type { AddWiring } from '../types.js';
+/**
+ * Inspect pikkuApprovalDescription() calls and extract metadata
+ */
+export declare const addApprovalDescription: AddWiring;

package/dist/add/add-approval-description.js

@@ -0,0 +1,52 @@
+import * as ts from 'typescript';
+import { extractFunctionName } from '../utils/extract-function-name.js';
+import { extractServicesFromFunction, extractUsedWires, } from '../utils/extract-services.js';
+/**
+ * Inspect pikkuApprovalDescription() calls and extract metadata
+ */
+export const addApprovalDescription = (logger, node, checker, state) => {
+    if (!ts.isCallExpression(node))
+        return;
+    const { expression, arguments: args } = node;
+    if (!ts.isIdentifier(expression))
+        return;
+    if (expression.text !== 'pikkuApprovalDescription')
+        return;
+    const arg = args[0];
+    if (!arg)
+        return;
+    let actualHandler;
+    if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
+        actualHandler = arg;
+    }
+    else {
+        logger.error(`• Handler for pikkuApprovalDescription is not a function.`);
+        return;
+    }
+    const services = extractServicesFromFunction(actualHandler);
+    const wires = extractUsedWires(actualHandler, 1);
+    let { pikkuFuncId, exportedName } = extractFunctionName(node, checker, state.rootDir);
+    if (pikkuFuncId.startsWith('__temp_')) {
+        if (ts.isVariableDeclaration(node.parent) &&
+            ts.isIdentifier(node.parent.name)) {
+            pikkuFuncId = node.parent.name.text;
+        }
+        else if (ts.isPropertyAssignment(node.parent) &&
+            ts.isIdentifier(node.parent.name)) {
+            pikkuFuncId = node.parent.name.text;
+        }
+        else {
+            logger.error(`• pikkuApprovalDescription() must be assigned to a variable or object property. ` +
+                `Extract it to a const: const myApproval = pikkuApprovalDescription(...)`);
+            return;
+        }
+    }
+    state.functions.approvalDescriptions[pikkuFuncId] = {
+        services,
+        wires: wires.wires.length > 0 || !wires.optimized ? wires : undefined,
+        sourceFile: node.getSourceFile().fileName,
+        position: node.getStart(),
+        exportedName,
+    };
+    logger.debug(`• Found approval description '${pikkuFuncId}' with services: ${services.services.join(', ')}`);
+};

package/dist/add/add-channel.js

@@ -7,6 +7,8 @@ import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
 import { resolveMiddleware, resolveChannelMiddleware, } from '../utils/middleware.js';
 import { extractWireNames } from '../utils/post-process.js';
 import { resolveIdentifier } from '../utils/resolve-identifier.js';
+import { resolveFunctionMeta } from '../utils/resolve-function-meta.js';
+import { resolveAddonName } from '../utils/resolve-addon-package.js';
 import { validateAuthSessionless } from '../utils/validate-auth-sessionless.js';
 /**
  * Safely get the "initializer" expression of a property-like AST node:
@@ -63,6 +65,13 @@ function getHandlerNameFromExpression(expr, checker, rootDir) {
     }
     // Handle call expressions
     if (ts.isCallExpression(expr)) {
+        // Handle addon('namespace:funcName') calls
+        if (ts.isIdentifier(expr.expression) && expr.expression.text === 'addon') {
+            const [firstArg] = expr.arguments;
+            if (firstArg && ts.isStringLiteral(firstArg)) {
+                return firstArg.text;
+            }
+        }
         const { pikkuFuncId } = extractFunctionName(expr, checker, rootDir);
         return pikkuFuncId;
     }
@@ -315,9 +324,9 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                 logger.error(`Could not resolve handler for message route '${routeKey}'`);
                 continue;
             }
-            const fnMeta = state.functions.meta[handlerName];
+            const fnMeta = resolveFunctionMeta(state, handlerName);
             if (!fnMeta) {
-                logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for handler '${handlerName}'`);
+                logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for channel handler '${handlerName}' on route '${routeKey}'. If this is an inline function, it must be exported for the inspector to discover it.`);
                 continue;
             }
             // Resolve middleware and permissions for this route
@@ -328,8 +337,15 @@ export function addMessagesRoutes(logger, obj, state, checker) {
             const routeMiddleware = ts.isObjectLiteralExpression(init)
                 ? resolveMiddleware(state, init, routeTags, checker)
                 : undefined;
+            // Resolve package name for addon functions (e.g. 'swaggerPetstore:addPet')
+            const colonIdx = handlerName.indexOf(':');
+            const addonNs = colonIdx !== -1 ? handlerName.substring(0, colonIdx) : null;
+            const packageName = addonNs
+                ? state.rpc.wireAddonDeclarations.get(addonNs)?.package
+                : undefined;
             result[channelKey][routeKey] = {
                 pikkuFuncId: handlerName,
+                packageName,
                 middleware: routeMiddleware,
             };
         }
@@ -382,8 +398,12 @@ export const addChannel = (logger, node, checker, state, options) => {
             logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for onMessage handler '${msgFuncId}'`);
             return;
         }
+        const msgPackageName = ts.isIdentifier(onMsgProp)
+            ? resolveAddonName(onMsgProp, checker, state.rpc.wireAddonDeclarations)
+            : null;
         message = {
             pikkuFuncId: msgFuncId,
+            ...(msgPackageName && { packageName: msgPackageName }),
         };
     }
     // nested message-routes
@@ -394,19 +414,27 @@ export const addChannel = (logger, node, checker, state, options) => {
     // --- track used functions/middleware for service aggregation ---
     // Track connect/disconnect/message handlers
     let connectFuncId;
+    let connectPackageName = null;
     if (connect) {
         const extracted = extractFunctionName(connect, checker, state.rootDir);
         connectFuncId = extracted.pikkuFuncId.startsWith('__temp_')
             ? makeContextBasedId('channel', name, 'connect')
             : extracted.pikkuFuncId;
+        connectPackageName = ts.isIdentifier(connect)
+            ? resolveAddonName(connect, checker, state.rpc.wireAddonDeclarations)
+            : null;
         state.serviceAggregation.usedFunctions.add(connectFuncId);
     }
     let disconnectFuncId;
+    let disconnectPackageName = null;
     if (disconnect) {
         const extracted = extractFunctionName(disconnect, checker, state.rootDir);
         disconnectFuncId = extracted.pikkuFuncId.startsWith('__temp_')
             ? makeContextBasedId('channel', name, 'disconnect')
             : extracted.pikkuFuncId;
+        disconnectPackageName = ts.isIdentifier(disconnect)
+            ? resolveAddonName(disconnect, checker, state.rpc.wireAddonDeclarations)
+            : null;
         state.serviceAggregation.usedFunctions.add(disconnectFuncId);
     }
     if (message) {
@@ -436,8 +464,18 @@ export const addChannel = (logger, node, checker, state, options) => {
         input: null,
         params: params.length ? params : undefined,
         query: query?.length ? query : undefined,
-        connect: connectFuncId ? { pikkuFuncId: connectFuncId } : null,
-        disconnect: disconnectFuncId ? { pikkuFuncId: disconnectFuncId } : null,
+        connect: connectFuncId
+            ? {
+                pikkuFuncId: connectFuncId,
+                ...(connectPackageName && { packageName: connectPackageName }),
+            }
+            : null,
+        disconnect: disconnectFuncId
+            ? {
+                pikkuFuncId: disconnectFuncId,
+                ...(disconnectPackageName && { packageName: disconnectPackageName }),
+            }
+            : null,
         message,
         messageWirings,
         binary: binary === undefined ? undefined : binary,

package/dist/add/add-cli.js

@@ -1,9 +1,11 @@
 import ts from 'typescript';
 import { extractFunctionName, makeContextBasedId, } from '../utils/extract-function-name.js';
 import { resolveMiddleware } from '../utils/middleware.js';
+import { resolveFunctionMeta } from '../utils/resolve-function-meta.js';
 import { extractWireNames } from '../utils/post-process.js';
 import { getPropertyValue } from '../utils/get-property-value.js';
 import { resolveIdentifier } from '../utils/resolve-identifier.js';
+import { resolveAddonName } from '../utils/resolve-addon-package.js';
 import { validateAuthSessionless } from '../utils/validate-auth-sessionless.js';
 // Track if we've warned about missing Config type to avoid duplicate warnings
 const configTypeWarningShown = new Set();
@@ -202,11 +204,38 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
             continue;
         const propName = prop.name.text;
         if (propName === 'func') {
-            pikkuFuncId = extractFunctionName(prop.initializer, typeChecker, inspectorState.rootDir).pikkuFuncId;
-            if (pikkuFuncId.startsWith('__temp_')) {
-                pikkuFuncId = makeContextBasedId('cli', programName, ...fullPath);
+            if (ts.isCallExpression(prop.initializer) &&
+                ts.isIdentifier(prop.initializer.expression) &&
+                prop.initializer.expression.text === 'addon') {
+                const [firstArg] = prop.initializer.arguments;
+                if (!firstArg || !ts.isStringLiteral(firstArg)) {
+                    throw new Error(`addon() call requires a string literal argument in the form "namespace:funcName"`);
+                }
+                pikkuFuncId = firstArg.text;
+                const addonNamespace = pikkuFuncId.split(':')[0];
+                if (!addonNamespace || !pikkuFuncId.includes(':')) {
+                    throw new Error(`Malformed addon function ID "${pikkuFuncId}": expected "namespace:funcName" format`);
+                }
+                if (!inspectorState.rpc.wireAddonDeclarations.has(addonNamespace)) {
+                    throw new Error(`Unknown addon namespace "${addonNamespace}" in "${pikkuFuncId}": no matching wireAddonDeclarations entry found`);
+                }
+                meta.pikkuFuncId = pikkuFuncId;
+                meta.packageName =
+                    inspectorState.rpc.wireAddonDeclarations.get(addonNamespace).package;
+            }
+            else {
+                pikkuFuncId = extractFunctionName(prop.initializer, typeChecker, inspectorState.rootDir).pikkuFuncId;
+                if (pikkuFuncId.startsWith('__temp_')) {
+                    pikkuFuncId = makeContextBasedId('cli', programName, ...fullPath);
+                }
+                meta.pikkuFuncId = pikkuFuncId;
+                const cliPackageName = ts.isIdentifier(prop.initializer)
+                    ? resolveAddonName(prop.initializer, typeChecker, inspectorState.rpc.wireAddonDeclarations)
+                    : null;
+                if (cliPackageName) {
+                    meta.packageName = cliPackageName;
+                }
             }
-            meta.pikkuFuncId = pikkuFuncId;
         }
         else if (propName === 'options' &&
             ts.isObjectLiteralExpression(prop.initializer)) {
@@ -357,17 +386,20 @@ function processOptions(logger, node, typeChecker, inspectorState, inspectorOpti
                 }
             }
             // Extract enum values from the function input type if available
-            // Get the input type if we have a pikkuFuncId
-            let inputTypes;
-            if (pikkuFuncId) {
-                inputTypes = inspectorState.typesLookup.get(pikkuFuncId);
-            }
             let derivedChoices = null;
-            if (inputTypes && inputTypes.length > 0) {
-                derivedChoices = extractEnumFromPropertyType(inputTypes[0], optionName, typeChecker);
+            if (pikkuFuncId) {
+                // 1. Try TypeScript types first (most precise — handles unions, TS enums)
+                const inputTypes = inspectorState.typesLookup.get(pikkuFuncId);
+                if (inputTypes && inputTypes.length > 0) {
+                    derivedChoices = extractEnumFromPropertyType(inputTypes[0], optionName, typeChecker);
+                }
+                // 2. Fallback: try JSON schema (works for addon functions)
+                if (!derivedChoices) {
+                    derivedChoices = extractEnumFromJsonSchema(inspectorState, pikkuFuncId, optionName);
+                }
             }
-            else {
-                // Fallback: try to extract from Config type
+            // 3. Last resort: try Config type
+            if (!derivedChoices) {
                 derivedChoices = extractEnumFromConfigType(logger, optionName, typeChecker, inspectorState, inspectorOptions);
             }
             // Validate and set choices
@@ -488,6 +520,34 @@ function extractEnumFromConfigType(logger, propertyName, typeChecker, inspectorS
     // Extract enum from the property
     return extractEnumFromPropertyType(configType, propertyName, typeChecker);
 }
+/**
+ * Extracts enum values from the function's JSON schema.
+ * Works for addon functions whose schemas are generated from OpenAPI/Zod.
+ */
+function extractEnumFromJsonSchema(inspectorState, pikkuFuncId, propertyName) {
+    const fnMeta = resolveFunctionMeta(inspectorState, pikkuFuncId);
+    if (!fnMeta?.inputSchemaName)
+        return null;
+    const schema = inspectorState.schemas[fnMeta.inputSchemaName];
+    if (!schema?.properties?.[propertyName])
+        return null;
+    const prop = schema.properties[propertyName];
+    // Direct enum on property
+    if (prop.enum && Array.isArray(prop.enum)) {
+        const strings = prop.enum.filter((v) => typeof v === 'string');
+        if (strings.length > 0)
+            return strings;
+    }
+    // Array with enum items (e.g. z.array(z.enum([...])))
+    if (prop.type === 'array' &&
+        prop.items?.enum &&
+        Array.isArray(prop.items.enum)) {
+        const strings = prop.items.enum.filter((v) => typeof v === 'string');
+        if (strings.length > 0)
+            return strings;
+    }
+    return null;
+}
 /**
  * Gets the property name from a property assignment
  */

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

@@ -7,6 +7,7 @@ const wrapperFunctionMap = {
     pikkuServices: 'CreateSingletonServices',
     pikkuAddonServices: 'CreateSingletonServices',
     pikkuWireServices: 'CreateWireServices',
+    pikkuAddonWireServices: 'CreateWireServices',
 };
 export const addFileWithFactory = (node, checker, methods = new Map(), expectedTypeName, state) => {
     if (ts.isVariableDeclaration(node)) {

package/dist/add/add-functions.js

@@ -245,7 +245,8 @@ export const addFunctions = (logger, node, checker, state, options) => {
     let remote;
     let mcp;
     let readonly_;
-    let requiresApproval;
+    let approvalRequired;
+    let approvalDescription;
     let version;
     let objectNode;
     let nodeDisplayName = null;
@@ -311,7 +312,24 @@ export const addFunctions = (logger, node, checker, state, options) => {
         remote = getPropertyValue(firstArg, 'remote');
         mcp = getPropertyValue(firstArg, 'mcp');
         readonly_ = getPropertyValue(firstArg, 'readonly');
-        requiresApproval = getPropertyValue(firstArg, 'requiresApproval');
+        approvalRequired = getPropertyValue(firstArg, 'approvalRequired');
+        // Extract approvalDescription identifier reference
+        for (const prop of firstArg.properties) {
+            if (ts.isPropertyAssignment(prop) &&
+                ts.isIdentifier(prop.name) &&
+                prop.name.text === 'approvalDescription' &&
+                ts.isIdentifier(prop.initializer)) {
+                const { pikkuFuncId: descId } = extractFunctionName(prop.initializer, checker, state.rootDir);
+                if (descId && !descId.startsWith('__temp_')) {
+                    approvalDescription = descId;
+                }
+                else {
+                    // Try resolving the identifier directly
+                    approvalDescription = prop.initializer.text;
+                }
+                break;
+            }
+        }
         const versionRaw = getPropertyValue(firstArg, 'version');
         if (versionRaw !== null && versionRaw !== undefined) {
             const parsed = Number(versionRaw);
@@ -565,7 +583,8 @@ export const addFunctions = (logger, node, checker, state, options) => {
         remote: remote || undefined,
         mcp: mcpEnabled || undefined,
         readonly: readonly_ || undefined,
-        requiresApproval: requiresApproval || undefined,
+        approvalRequired: approvalRequired || undefined,
+        approvalDescription: approvalDescription || undefined,
         version,
         title,
         tags: tags || undefined,

package/dist/add/add-gateway.js

@@ -4,6 +4,7 @@ import { extractFunctionName, makeContextBasedId, } from '../utils/extract-funct
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
 import { resolveMiddleware } from '../utils/middleware.js';
 import { extractWireNames } from '../utils/post-process.js';
+import { resolveAddonName } from '../utils/resolve-addon-package.js';
 import { ErrorCode } from '../error-codes.js';
 export const addGateway = (logger, node, checker, state, _options) => {
     if (!ts.isCallExpression(node)) {
@@ -35,6 +36,9 @@ export const addGateway = (logger, node, checker, state, _options) => {
     if (pikkuFuncId.startsWith('__temp_') && nameValue) {
         pikkuFuncId = makeContextBasedId('gateway', nameValue);
     }
+    const packageName = ts.isIdentifier(funcInitializer)
+        ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+        : null;
     if (!nameValue || !typeValue) {
         return;
     }
@@ -44,6 +48,7 @@ export const addGateway = (logger, node, checker, state, _options) => {
     state.gateways.files.add(node.getSourceFile().fileName);
     state.gateways.meta[nameValue] = {
         pikkuFuncId,
+        ...(packageName && { packageName }),
         name: nameValue,
         type: typeValue,
         route: routeValue,

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

@@ -10,6 +10,7 @@ import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.js';
 import { ErrorCode } from '../error-codes.js';
 import { validateAuthSessionless } from '../utils/validate-auth-sessionless.js';
 import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js';
+import { resolveAddonName } from '../utils/resolve-addon-package.js';
 /**
  * Extract header schema reference from headers property
  */
@@ -112,6 +113,9 @@ export function registerHTTPRoute({ obj, state, checker, logger, sourceFile, bas
     if (funcName.startsWith('__temp_')) {
         funcName = makeContextBasedId('http', method, fullRoute);
     }
+    const packageName = ts.isIdentifier(funcInitializer)
+        ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+        : null;
     ensureFunctionMetadata(state, funcName, fullRoute, funcInitializer, checker, extracted.isHelper);
     // Lookup existing function metadata
     const fnMeta = state.functions.meta[funcName];
@@ -168,6 +172,7 @@ export function registerHTTPRoute({ obj, state, checker, logger, sourceFile, bas
     state.http.files.add(sourceFile.fileName);
     state.http.meta[method][fullRoute] = {
         pikkuFuncId: funcName,
+        ...(packageName && { packageName }),
         route: fullRoute,
         method: method,
         params: params.length > 0 ? params : undefined,

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

@@ -6,6 +6,7 @@ import { extractFunctionName, makeContextBasedId, } from '../utils/extract-funct
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
 import { resolveMiddleware } from '../utils/middleware.js';
 import { resolvePermissions } from '../utils/permissions.js';
+import { resolveAddonName } from '../utils/resolve-addon-package.js';
 import { ErrorCode } from '../error-codes.js';
 export const addMCPPrompt = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
@@ -37,6 +38,9 @@ export const addMCPPrompt = (logger, node, checker, state, options) => {
         if (pikkuFuncId.startsWith('__temp_') && nameValue) {
             pikkuFuncId = makeContextBasedId('mcp', 'prompt', nameValue);
         }
+        const packageName = ts.isIdentifier(funcInitializer)
+            ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+            : null;
         ensureFunctionMetadata(state, pikkuFuncId, nameValue || undefined, funcInitializer, checker, extracted.isHelper);
         if (!nameValue) {
             logger.critical(ErrorCode.MISSING_NAME, "MCP prompt is missing the required 'name' property.");
@@ -65,6 +69,7 @@ export const addMCPPrompt = (logger, node, checker, state, options) => {
         state.mcpEndpoints.files.add(node.getSourceFile().fileName);
         state.mcpEndpoints.promptsMeta[nameValue] = {
             pikkuFuncId,
+            ...(packageName && { packageName }),
             name: nameValue,
             description,
             summary,

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

@@ -6,6 +6,7 @@ import { extractFunctionName, makeContextBasedId, } from '../utils/extract-funct
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
 import { resolveMiddleware } from '../utils/middleware.js';
 import { resolvePermissions } from '../utils/permissions.js';
+import { resolveAddonName } from '../utils/resolve-addon-package.js';
 import { ErrorCode } from '../error-codes.js';
 export const addMCPResource = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
@@ -42,6 +43,9 @@ export const addMCPResource = (logger, node, checker, state, options) => {
         if (pikkuFuncId.startsWith('__temp_') && uriValue) {
             pikkuFuncId = makeContextBasedId('mcp', 'resource', uriValue);
         }
+        const packageName = ts.isIdentifier(funcInitializer)
+            ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+            : null;
         ensureFunctionMetadata(state, pikkuFuncId, uriValue || undefined, funcInitializer, checker, extracted.isHelper);
         if (!uriValue) {
             logger.critical(ErrorCode.MISSING_URI, "MCP resource is missing the required 'uri' property.");
@@ -74,6 +78,7 @@ export const addMCPResource = (logger, node, checker, state, options) => {
         state.mcpEndpoints.files.add(node.getSourceFile().fileName);
         state.mcpEndpoints.resourcesMeta[uriValue] = {
             pikkuFuncId,
+            ...(packageName && { packageName }),
             uri: uriValue,
             title: titleValue,
             description,

package/dist/add/add-middleware.js

@@ -189,12 +189,10 @@ export const addMiddleware = (logger, node, checker, state) => {
             return;
         }
         const refs = extractMiddlewareRefs(middlewareArrayArg, checker, state.rootDir);
-        if (refs.length === 0) {
-            logger.warn(`• addMiddleware('${tag}', ...) has empty middleware array`);
-            return;
-        }
         const definitionIds = refs.map((r) => r.definitionId);
-        renameTempDefinitions(state, definitionIds, 'tag', tag);
+        if (definitionIds.length > 0) {
+            renameTempDefinitions(state, definitionIds, 'tag', tag);
+        }
         const sourceFile = node.getSourceFile().fileName;
         const instanceIds = [];
         for (let i = 0; i < refs.length; i++) {
@@ -273,12 +271,10 @@ export const addMiddleware = (logger, node, checker, state) => {
             return;
         }
         const refs = extractMiddlewareRefs(middlewareArrayArg, checker, state.rootDir);
-        if (refs.length === 0) {
-            logger.warn(`• addHTTPMiddleware('${pattern}', ...) has empty middleware array`);
-            return;
-        }
         const definitionIds = refs.map((r) => r.definitionId);
-        renameTempDefinitions(state, definitionIds, 'http', pattern);
+        if (definitionIds.length > 0) {
+            renameTempDefinitions(state, definitionIds, 'http', pattern);
+        }
         const sourceFile = node.getSourceFile().fileName;
         const instanceIds = [];
         for (let i = 0; i < refs.length; i++) {

package/dist/add/add-permission.js

@@ -21,12 +21,14 @@ function renameTempDefinitions(state, definitionIds, groupType, groupKey) {
         definitionIds[idx] = newId;
     }
 }
-function isInsidePermissionFactory(node) {
+function isInsidePermissionContainer(node) {
     let current = node.parent;
     while (current) {
         if (ts.isCallExpression(current) &&
             ts.isIdentifier(current.expression) &&
-            current.expression.text === 'pikkuPermissionFactory') {
+            (current.expression.text === 'pikkuPermissionFactory' ||
+                current.expression.text === 'addPermission' ||
+                current.expression.text === 'addHTTPPermission')) {
             return true;
         }
         current = current.parent;
@@ -47,7 +49,7 @@ export const addPermission = (logger, node, checker, state) => {
     // Handle pikkuPermission(...) - individual permission function definition
     if (expression.text === 'pikkuPermission') {
         // Skip if nested inside pikkuPermissionFactory — the factory handler extracts services itself
-        if (isInsidePermissionFactory(node))
+        if (isInsidePermissionContainer(node))
             return;
         const arg = args[0];
         if (!arg)
@@ -110,7 +112,7 @@ export const addPermission = (logger, node, checker, state) => {
         return;
     }
     if (expression.text === 'pikkuAuth') {
-        if (isInsidePermissionFactory(node))
+        if (isInsidePermissionContainer(node))
             return;
         const arg = args[0];
         if (!arg)
@@ -269,11 +271,9 @@ export const addPermission = (logger, node, checker, state) => {
         }
         // Extract permission pikkuFuncIds from array
         const permissionNames = extractPermissionPikkuNames(permissionsArrayArg, checker, state.rootDir);
-        if (permissionNames.length === 0) {
-            logger.warn(`• addPermission('${tag}', ...) has empty permissions array`);
-            return;
+        if (permissionNames.length > 0) {
+            renameTempDefinitions(state, permissionNames, 'tag', tag);
         }
-        renameTempDefinitions(state, permissionNames, 'tag', tag);
         const allServices = new Set();
         for (const permissionName of permissionNames) {
             const permissionMeta = state.permissions.definitions[permissionName];
@@ -348,11 +348,9 @@ export const addPermission = (logger, node, checker, state) => {
         }
         // Extract permission pikkuFuncIds from array
         const permissionNames = extractPermissionPikkuNames(permissionsArrayArg, checker, state.rootDir);
-        if (permissionNames.length === 0) {
-            logger.warn(`• addHTTPPermission('${pattern}', ...) has empty permissions array`);
-            return;
+        if (permissionNames.length > 0) {
+            renameTempDefinitions(state, permissionNames, 'http', pattern);
         }
-        renameTempDefinitions(state, permissionNames, 'http', pattern);
         const allServices = new Set();
         for (const permissionName of permissionNames) {
             const permissionMeta = state.permissions.definitions[permissionName];

package/dist/add/add-queue-worker.js

@@ -4,6 +4,7 @@ import { extractFunctionName, makeContextBasedId, } from '../utils/extract-funct
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
 import { resolveMiddleware } from '../utils/middleware.js';
 import { extractWireNames } from '../utils/post-process.js';
+import { resolveAddonName } from '../utils/resolve-addon-package.js';
 import { ErrorCode } from '../error-codes.js';
 export const addQueueWorker = (logger, node, checker, state) => {
     if (!ts.isCallExpression(node)) {
@@ -36,6 +37,9 @@ export const addQueueWorker = (logger, node, checker, state) => {
         if (pikkuFuncId.startsWith('__temp_') && name) {
             pikkuFuncId = makeContextBasedId('queue', name);
         }
+        const packageName = ts.isIdentifier(funcInitializer)
+            ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+            : null;
         if (!name) {
             logger.critical(ErrorCode.MISSING_QUEUE_NAME, `No 'name' provided for queue processor function '${pikkuFuncId}'.`);
             return;
@@ -48,6 +52,7 @@ export const addQueueWorker = (logger, node, checker, state) => {
         state.queueWorkers.files.add(node.getSourceFile().fileName);
         state.queueWorkers.meta[name] = {
             pikkuFuncId,
+            ...(packageName && { packageName }),
             name,
             summary,
             description,