@pikku/inspector 0.12.2 → 0.12.4

package/dist/utils/workflow/graph/convert-dsl-to-graph.js

@@ -301,6 +301,7 @@ export function convertDslToGraph(workflowName, meta) {
         source,
         description: meta.description,
         tags: meta.tags,
+        inline: meta.inline,
         context: meta.context,
         nodes: nodesRecord,
         entryNodeIds,

package/dist/utils/workflow/graph/workflow-graph.types.d.ts

@@ -141,6 +141,8 @@ export interface SerializedWorkflowGraph {
     description?: string;
     /** Tags for organization */
     tags?: string[];
+    /** If true, workflow always executes inline without queues */
+    inline?: boolean;
     /** Workflow context/state variables (from Zod schema) */
     context?: WorkflowContext;
     /** Serialized nodes */

package/dist/visit.js

@@ -21,6 +21,7 @@ import { addSecret, addOAuth2Credential } from './add/add-secret.js';
 import { addVariable } from './add/add-variable.js';
 import { addWorkflowGraph } from './add/add-workflow-graph.js';
 import { addAIAgent } from './add/add-ai-agent.js';
+import { addApprovalDescription } from './add/add-approval-description.js';
 export const visitSetup = (logger, checker, node, state, options) => {
     addFileExtendsCoreType(node, checker, state.singletonServicesTypeImportMap, 'CoreSingletonServices', state);
     addFileExtendsCoreType(node, checker, state.wireServicesTypeImportMap, 'CoreServices', state);
@@ -33,6 +34,7 @@ export const visitSetup = (logger, checker, node, state, options) => {
     addWireAddon(node, state, logger);
     addMiddleware(logger, node, checker, state, options);
     addPermission(logger, node, checker, state, options);
+    addApprovalDescription(logger, node, checker, state, options);
     addWorkflow(logger, node, checker, state, options);
     ts.forEachChild(node, (child) => visitSetup(logger, checker, child, state, options));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.2",
+  "version": "0.12.4",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "type": "module",
@@ -30,11 +30,12 @@
     "release": "yarn build && npm test",
     "test": "bash run-tests.sh",
     "test:watch": "bash run-tests.sh --watch",
-    "test:coverage": "bash run-tests.sh --coverage"
+    "test:coverage": "bash run-tests.sh --coverage",
+    "prepublishOnly": "yarn build"
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.1",
-    "@pikku/core": "^0.12.2",
+    "@pikku/core": "^0.12.9",
     "path-to-regexp": "^8.3.0",
     "ts-json-schema-generator": "^2.5.0",
     "tsx": "^4.21.0",

package/src/add/add-ai-agent.ts

@@ -268,6 +268,9 @@ export const addAIAgent: AddWiring = (
       | number
       | null
     const toolChoiceValue = getPropertyValue(obj, 'toolChoice') as string | null
+    const dynamicWorkflowsValue = getPropertyValue(obj, 'dynamicWorkflows') as
+      | string
+      | null
     const toolsValue = resolveToolReferences(
       obj,
       checker,
@@ -455,6 +458,9 @@ export const addAIAgent: AddWiring = (
       }),
       ...(toolsValue !== null && { tools: toolsValue }),
       ...(agentsValue !== null && { agents: agentsValue }),
+      ...(dynamicWorkflowsValue !== null && {
+        dynamicWorkflows: dynamicWorkflowsValue as 'read' | 'always' | 'ask',
+      }),
       tags,
       inputSchema,
       outputSchema,

package/src/add/add-approval-description.ts

@@ -0,0 +1,76 @@
+import * as ts from 'typescript'
+import type { AddWiring } from '../types.js'
+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: AddWiring = (
+  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: ts.ArrowFunction | ts.FunctionExpression
+
+  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/src/add/add-channel.ts

@@ -18,6 +18,8 @@ import {
 } 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'
 
 /**
@@ -92,6 +94,13 @@ function getHandlerNameFromExpression(
 
   // 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
   }
@@ -460,11 +469,11 @@ export function addMessagesRoutes(
         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}'`
+          `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
       }
@@ -478,8 +487,17 @@ export function addMessagesRoutes(
         ? 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,
       }
     }
@@ -564,8 +582,12 @@ export const addChannel: AddWiring = (
       )
       return
     }
+    const msgPackageName = ts.isIdentifier(onMsgProp)
+      ? resolveAddonName(onMsgProp, checker, state.rpc.wireAddonDeclarations)
+      : null
     message = {
       pikkuFuncId: msgFuncId,
+      ...(msgPackageName && { packageName: msgPackageName }),
     }
   }
 
@@ -579,15 +601,20 @@ export const addChannel: AddWiring = (
   // --- track used functions/middleware for service aggregation ---
   // Track connect/disconnect/message handlers
   let connectFuncId: string | undefined
+  let connectPackageName: string | null = 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: string | undefined
+  let disconnectPackageName: string | null = null
   if (disconnect) {
     const extracted = extractFunctionName(
       disconnect as any,
@@ -597,6 +624,9 @@ export const addChannel: AddWiring = (
     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)
   }
 
@@ -634,8 +664,18 @@ export const addChannel: AddWiring = (
     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/src/add/add-cli.ts

@@ -12,9 +12,11 @@ import {
   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
@@ -344,15 +346,53 @@ function processCommand(
     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)
@@ -573,22 +613,31 @@ function processOptions(
       }
 
       // Extract enum values from the function input type if available
-      // Get the input type if we have a pikkuFuncId
-      let inputTypes: ts.Type[] | undefined
+      let derivedChoices: string[] | null = null
+
       if (pikkuFuncId) {
-        inputTypes = inspectorState.typesLookup.get(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
+          )
+        }
 
-      let derivedChoices: string[] | null = null
+        // 2. Fallback: try JSON schema (works for addon functions)
+        if (!derivedChoices) {
+          derivedChoices = extractEnumFromJsonSchema(
+            inspectorState,
+            pikkuFuncId,
+            optionName
+          )
+        }
+      }
 
-      if (inputTypes && inputTypes.length > 0) {
-        derivedChoices = extractEnumFromPropertyType(
-          inputTypes[0]!,
-          optionName,
-          typeChecker
-        )
-      } else {
-        // Fallback: try to extract from Config type
+      // 3. Last resort: try Config type
+      if (!derivedChoices) {
         derivedChoices = extractEnumFromConfigType(
           logger,
           optionName,
@@ -750,6 +799,44 @@ function extractEnumFromConfigType(
   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: InspectorState,
+  pikkuFuncId: string,
+  propertyName: string
+): string[] | null {
+  const fnMeta = resolveFunctionMeta(inspectorState, pikkuFuncId)
+  if (!fnMeta?.inputSchemaName) return null
+
+  const schema = inspectorState.schemas[fnMeta.inputSchemaName] as any
+  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: unknown) => 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: unknown) => typeof v === 'string'
+    )
+    if (strings.length > 0) return strings
+  }
+
+  return null
+}
+
 /**
  * Gets the property name from a property assignment
  */

package/src/add/add-file-with-factory.ts

@@ -9,6 +9,7 @@ const wrapperFunctionMap: Record<string, string> = {
   pikkuServices: 'CreateSingletonServices',
   pikkuAddonServices: 'CreateSingletonServices',
   pikkuWireServices: 'CreateWireServices',
+  pikkuAddonWireServices: 'CreateWireServices',
 }
 
 export const addFileWithFactory = (

package/src/add/add-functions.ts

@@ -339,7 +339,8 @@ export const addFunctions: AddWiring = (
   let remote: boolean | undefined
   let mcp: boolean | undefined
   let readonly_: boolean | undefined
-  let requiresApproval: boolean | undefined
+  let approvalRequired: boolean | undefined
+  let approvalDescription: string | undefined
   let version: number | undefined
   let objectNode: ts.ObjectLiteralExpression | undefined
   let nodeDisplayName: string | null = null
@@ -421,10 +422,33 @@ export const addFunctions: AddWiring = (
     remote = getPropertyValue(firstArg, 'remote') as boolean | undefined
     mcp = getPropertyValue(firstArg, 'mcp') as boolean | undefined
     readonly_ = getPropertyValue(firstArg, 'readonly') as boolean | undefined
-    requiresApproval = getPropertyValue(firstArg, 'requiresApproval') as
+    approvalRequired = getPropertyValue(firstArg, 'approvalRequired') as
       | boolean
       | undefined
 
+    // 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)
@@ -759,7 +783,8 @@ export const addFunctions: AddWiring = (
     remote: remote || undefined,
     mcp: mcpEnabled || undefined,
     readonly: readonly_ || undefined,
-    requiresApproval: requiresApproval || undefined,
+    approvalRequired: approvalRequired || undefined,
+    approvalDescription: approvalDescription || undefined,
     version,
     title,
     tags: tags || undefined,

package/src/add/add-gateway.ts

@@ -11,6 +11,7 @@ import {
 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 type { GatewayTransportType } from '@pikku/core/gateway'
 
 import { ErrorCode } from '../error-codes.js'
@@ -68,6 +69,10 @@ export const addGateway: AddWiring = (
     pikkuFuncId = makeContextBasedId('gateway', nameValue)
   }
 
+  const packageName = ts.isIdentifier(funcInitializer)
+    ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+    : null
+
   if (!nameValue || !typeValue) {
     return
   }
@@ -82,6 +87,7 @@ export const addGateway: AddWiring = (
   state.gateways.files.add(node.getSourceFile().fileName)
   state.gateways.meta[nameValue] = {
     pikkuFuncId,
+    ...(packageName && { packageName }),
     name: nameValue,
     type: typeValue,
     route: routeValue,

package/src/add/add-http-route.ts

@@ -21,6 +21,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'
 
 import type { InspectorLogger } from '../types.js'
 
@@ -203,6 +204,10 @@ export function registerHTTPRoute({
     funcName = makeContextBasedId('http', method, fullRoute)
   }
 
+  const packageName = ts.isIdentifier(funcInitializer)
+    ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+    : null
+
   ensureFunctionMetadata(
     state,
     funcName,
@@ -320,6 +325,7 @@ export function registerHTTPRoute({
   state.http.files.add(sourceFile.fileName)
   state.http.meta[method][fullRoute] = {
     pikkuFuncId: funcName,
+    ...(packageName && { packageName }),
     route: fullRoute,
     method: method as HTTPMethod,
     params: params.length > 0 ? params : undefined,

package/src/add/add-mcp-prompt.ts

@@ -13,6 +13,7 @@ import {
 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: AddWiring = (
@@ -72,6 +73,10 @@ export const addMCPPrompt: AddWiring = (
       pikkuFuncId = makeContextBasedId('mcp', 'prompt', nameValue)
     }
 
+    const packageName = ts.isIdentifier(funcInitializer)
+      ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+      : null
+
     ensureFunctionMetadata(
       state,
       pikkuFuncId,
@@ -128,6 +133,7 @@ export const addMCPPrompt: AddWiring = (
 
     state.mcpEndpoints.promptsMeta[nameValue] = {
       pikkuFuncId,
+      ...(packageName && { packageName }),
       name: nameValue,
       description,
       summary,

package/src/add/add-mcp-resource.ts

@@ -13,6 +13,7 @@ import {
 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: AddWiring = (
@@ -81,6 +82,10 @@ export const addMCPResource: AddWiring = (
       pikkuFuncId = makeContextBasedId('mcp', 'resource', uriValue)
     }
 
+    const packageName = ts.isIdentifier(funcInitializer)
+      ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+      : null
+
     ensureFunctionMetadata(
       state,
       pikkuFuncId,
@@ -145,6 +150,7 @@ export const addMCPResource: AddWiring = (
 
     state.mcpEndpoints.resourcesMeta[uriValue] = {
       pikkuFuncId,
+      ...(packageName && { packageName }),
       uri: uriValue,
       title: titleValue,
       description,

package/src/add/add-middleware.ts

@@ -274,13 +274,10 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
       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: string[] = []
@@ -384,15 +381,10 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
       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: string[] = []