@pikku/inspector 0.12.2 → 0.12.3

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## 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

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

package/dist/add/add-wire-addon.js

@@ -32,6 +32,7 @@ export function addWireAddon(node, state, logger) {
     let name;
     let pkg;
     let rpcEndpoint;
+    let mcp;
     let secretOverrides;
     let variableOverrides;
     for (const prop of firstArg.properties) {
@@ -47,6 +48,11 @@ export function addWireAddon(node, state, logger) {
         else if (key === 'rpcEndpoint' && ts.isStringLiteral(prop.initializer)) {
             rpcEndpoint = prop.initializer.text;
         }
+        else if (key === 'mcp' &&
+            (prop.initializer.kind === ts.SyntaxKind.TrueKeyword ||
+                prop.initializer.kind === ts.SyntaxKind.FalseKeyword)) {
+            mcp = prop.initializer.kind === ts.SyntaxKind.TrueKeyword;
+        }
         else if (key === 'secretOverrides' &&
             ts.isObjectLiteralExpression(prop.initializer)) {
             secretOverrides = parseStringRecord(prop.initializer);
@@ -62,6 +68,7 @@ export function addWireAddon(node, state, logger) {
     state.rpc.wireAddonDeclarations.set(name, {
         package: pkg,
         rpcEndpoint,
+        mcp,
         secretOverrides,
         variableOverrides,
     });

package/dist/index.d.ts

@@ -13,4 +13,5 @@ export { serializeMCPJson } from './utils/serialize-mcp-json.js';
 export type { OpenAPISpecInfo } from './utils/serialize-openapi-json.js';
 export { deserializeDslWorkflow, deserializeGraphWorkflow, deserializeAllDslWorkflows, } from './utils/workflow/dsl/index.js';
 export { getFilesAndMethods } from './utils/get-files-and-methods.js';
+export { resolveFunctionMeta } from './utils/resolve-function-meta.js';
 export type { SerializedWorkflowGraph, SerializedWorkflowGraphs, } from './utils/workflow/graph/index.js';

package/dist/index.js

@@ -7,3 +7,4 @@ export { createEmptyManifest, serializeManifest, } from './utils/contract-hashes
 export { serializeMCPJson } from './utils/serialize-mcp-json.js';
 export { deserializeDslWorkflow, deserializeGraphWorkflow, deserializeAllDslWorkflows, } from './utils/workflow/dsl/index.js';
 export { getFilesAndMethods } from './utils/get-files-and-methods.js';
+export { resolveFunctionMeta } from './utils/resolve-function-meta.js';

package/dist/inspector.js

@@ -11,6 +11,7 @@ import { resolveLatestVersions } from './utils/resolve-versions.js';
 import { finalizeWorkflows } from './utils/workflow/graph/finalize-workflows.js';
 import { finalizeWorkflowHelperTypes, finalizeWorkflowWires, } from './utils/workflow/graph/finalize-workflow-wires.js';
 import { generateAllSchemas } from './utils/schema-generator.js';
+import { loadAddonFunctionsMeta, loadAddonSchemas, } from './utils/load-addon-functions-meta.js';
 import { computeContractHashes, extractContractsFromMeta, updateManifest, createEmptyManifest, validateContracts, } from './utils/contract-hashes.js';
 /**
  * Creates an initial/empty inspector state with all required properties initialized
@@ -37,6 +38,7 @@ export function getInitialInspectorState(rootDir) {
             typesMap: new TypesMap(),
             meta: {},
             files: new Map(),
+            approvalDescriptions: {},
         },
         http: {
             metaInputTypes: new Map(),
@@ -171,6 +173,7 @@ export function getInitialInspectorState(rootDir) {
         requiredSchemas: new Set(),
         openAPISpec: null,
         diagnostics: [],
+        addonFunctions: {},
     };
 }
 export const inspect = async (logger, routeFiles, options = {}) => {
@@ -205,6 +208,8 @@ export const inspect = async (logger, routeFiles, options = {}) => {
         ts.forEachChild(sourceFile, (child) => visitSetup(logger, checker, child, state, options));
     }
     logger.debug(`Visit setup phase completed in ${(performance.now() - startSetup).toFixed(2)}ms`);
+    // Load addon function metadata so wirings can reference addon functions
+    await loadAddonFunctionsMeta(logger, state);
     if (!options.setupOnly) {
         // Second sweep: add all transports
         const startRoutes = performance.now();
@@ -218,6 +223,8 @@ export const inspect = async (logger, routeFiles, options = {}) => {
             computeContractHashes(state.schemas, state.functions.typesMap, state.functions.meta);
             computeRequiredSchemas(state, options);
         }
+        // Re-load addon schemas (generateAllSchemas replaces state.schemas)
+        await loadAddonSchemas(logger, state);
         state.manifest.initial = options.manifest ?? null;
         const contracts = extractContractsFromMeta(state.functions.meta);
         const baseManifest = state.manifest.initial ?? createEmptyManifest();