@pikku/inspector 0.12.1 → 0.12.3

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 ## 0.12.0
 
+## 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
+
+- 3e04565: chore: update dependencies to latest minor/patch versions
+- Updated dependencies [cc4c9e9]
+- Updated dependencies [3e04565]
+  - @pikku/core@0.12.2
+
 ## 0.12.1
 
 ### 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,
             };
         }
@@ -366,6 +382,7 @@ export const addChannel = (logger, node, checker, state, options) => {
     if (disabled)
         return;
     const query = getPropertyValue(obj, 'query');
+    const binary = getPropertyValue(obj, 'binary');
     const connect = getPropertyAssignmentInitializer(obj, 'onConnect', true, checker);
     const disconnect = getPropertyAssignmentInitializer(obj, 'onDisconnect', true, checker);
     // default onMessage handler
@@ -381,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
@@ -393,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) {
@@ -435,10 +464,21 @@ 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,
         summary,
         description,
         errors,

package/dist/add/add-cli.js

@@ -1,9 +1,11 @@
 import ts from 'typescript';
-import { extractFunctionName } from '../utils/extract-function-name.js';
+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();
@@ -95,10 +97,14 @@ function processCLIConfig(logger, node, sourceFile, typeChecker, inspectorState,
                     programMeta.options = processOptions(logger, prop.initializer, typeChecker, inspectorState, options);
                 }
                 break;
-            case 'render':
-                // Extract the actual renderer function name
-                programMeta.defaultRenderName = extractFunctionName(prop.initializer, typeChecker, inspectorState.rootDir).pikkuFuncId;
+            case 'render': {
+                let renderFuncId = extractFunctionName(prop.initializer, typeChecker, inspectorState.rootDir).pikkuFuncId;
+                if (renderFuncId.startsWith('__temp_')) {
+                    renderFuncId = makeContextBasedId('cli-render', programName);
+                }
+                programMeta.defaultRenderName = renderFuncId;
                 break;
+            }
         }
     }
     return { programName, programMeta };
@@ -156,8 +162,12 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
     if (ts.isIdentifier(node) ||
         ts.isArrowFunction(node) ||
         ts.isFunctionExpression(node)) {
+        let pikkuFuncId = extractFunctionName(node, typeChecker, inspectorState.rootDir).pikkuFuncId;
+        if (pikkuFuncId.startsWith('__temp_')) {
+            pikkuFuncId = makeContextBasedId('cli', programName, ...fullPath);
+        }
         return {
-            pikkuFuncId: extractFunctionName(node, typeChecker, inspectorState.rootDir).pikkuFuncId,
+            pikkuFuncId,
             positionals: [],
             options: {},
         };
@@ -194,8 +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;
-            meta.pikkuFuncId = pikkuFuncId;
+            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;
+                }
+            }
         }
         else if (propName === 'options' &&
             ts.isObjectLiteralExpression(prop.initializer)) {
@@ -238,9 +278,14 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
             case 'func':
                 // Already handled in first pass
                 break;
-            case 'render':
-                meta.renderName = extractFunctionName(prop.initializer, typeChecker, inspectorState.rootDir).pikkuFuncId;
+            case 'render': {
+                let renderFuncId = extractFunctionName(prop.initializer, typeChecker, inspectorState.rootDir).pikkuFuncId;
+                if (renderFuncId.startsWith('__temp_')) {
+                    renderFuncId = makeContextBasedId('cli-render', programName, ...fullPath);
+                }
+                meta.renderName = renderFuncId;
                 break;
+            }
             case 'options':
                 // Process with pikkuFuncId from first pass
                 if (optionsNode) {
@@ -341,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
@@ -472,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.d.ts

@@ -0,0 +1,2 @@
+import type { AddWiring } from '../types.js';
+export declare const addGateway: AddWiring;

package/dist/add/add-gateway.js

@@ -0,0 +1,62 @@
+import * as ts from 'typescript';
+import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
+import { extractFunctionName, makeContextBasedId, } from '../utils/extract-function-name.js';
+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)) {
+        return;
+    }
+    const args = node.arguments;
+    const firstArg = args[0];
+    const expression = node.expression;
+    if (!ts.isIdentifier(expression) || expression.text !== 'wireGateway') {
+        return;
+    }
+    if (!firstArg || !ts.isObjectLiteralExpression(firstArg)) {
+        return;
+    }
+    const obj = firstArg;
+    const nameValue = getPropertyValue(obj, 'name');
+    const typeValue = getPropertyValue(obj, 'type');
+    const routeValue = getPropertyValue(obj, 'route');
+    const { disabled, tags, summary, description, errors } = getCommonWireMetaData(obj, 'Gateway', nameValue, logger);
+    if (disabled)
+        return;
+    const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
+    if (!funcInitializer) {
+        logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for gateway '${nameValue}'.`);
+        return;
+    }
+    const extracted = extractFunctionName(funcInitializer, checker, state.rootDir);
+    let pikkuFuncId = extracted.pikkuFuncId;
+    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;
+    }
+    const middleware = resolveMiddleware(state, obj, tags, checker);
+    state.serviceAggregation.usedFunctions.add(pikkuFuncId);
+    extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
+    state.gateways.files.add(node.getSourceFile().fileName);
+    state.gateways.meta[nameValue] = {
+        pikkuFuncId,
+        ...(packageName && { packageName }),
+        name: nameValue,
+        type: typeValue,
+        route: routeValue,
+        gateway: true,
+        summary,
+        description,
+        errors,
+        tags,
+        middleware,
+    };
+};

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-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,

package/dist/add/add-schedule.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 addSchedule = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
@@ -36,6 +37,9 @@ export const addSchedule = (logger, node, checker, state, options) => {
         if (pikkuFuncId.startsWith('__temp_') && nameValue) {
             pikkuFuncId = makeContextBasedId('scheduler', nameValue);
         }
+        const packageName = ts.isIdentifier(funcInitializer)
+            ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+            : null;
         if (!nameValue || !scheduleValue) {
             return;
         }
@@ -47,6 +51,7 @@ export const addSchedule = (logger, node, checker, state, options) => {
         state.scheduledTasks.files.add(node.getSourceFile().fileName);
         state.scheduledTasks.meta[nameValue] = {
             pikkuFuncId,
+            ...(packageName && { packageName }),
             name: nameValue,
             schedule: scheduleValue,
             summary,