@pikku/inspector 0.11.0 → 0.11.2

package/src/add/add-workflow.ts

@@ -1,29 +1,75 @@
 import * as ts from 'typescript'
-import {
-  getPropertyValue,
-  getPropertyTags,
-} from '../utils/get-property-value.js'
-import { PikkuDocs } from '@pikku/core'
 import { AddWiring, InspectorState } from '../types.js'
 import { extractFunctionName } from '../utils/extract-function-name.js'
-import {
-  getPropertyAssignmentInitializer,
-  resolveFunctionDeclaration,
-} from '../utils/type-utils.js'
-import { resolveMiddleware } from '../utils/middleware.js'
-import { extractWireNames } from '../utils/post-process.js'
+import { extractFunctionNode } from '../utils/extract-function-node.js'
 import { ErrorCode } from '../error-codes.js'
-import { WorkflowStepMeta } from '@pikku/core/workflow'
+import { WorkflowStepMeta, WorkflowContext } from '@pikku/core/workflow'
 import {
   extractStringLiteral,
-  extractNumberLiteral,
-  extractPropertyString,
   isStringLike,
   isFunctionLike,
+  extractDescription,
+  extractDuration,
 } from '../utils/extract-node-value.js'
+import { getCommonWireMetaData } from '../utils/get-property-value.js'
+import { extractDSLWorkflow } from '../utils/workflow/dsl/extract-dsl-workflow.js'
+
+/**
+ * Recursively check if any step has inline type (non-serializable)
+ */
+function hasInlineSteps(steps: WorkflowStepMeta[]): boolean {
+  for (const step of steps) {
+    if (step.type === 'inline') {
+      return true
+    } else if (step.type === 'branch') {
+      for (const branch of step.branches) {
+        if (hasInlineSteps(branch.steps)) return true
+      }
+      if (step.elseSteps && hasInlineSteps(step.elseSteps)) return true
+    } else if (step.type === 'switch' && step.cases) {
+      for (const c of step.cases) {
+        if (c.steps && hasInlineSteps(c.steps)) return true
+      }
+      if (step.defaultSteps && hasInlineSteps(step.defaultSteps)) return true
+    } else if (step.type === 'fanout' && step.child) {
+      if (hasInlineSteps([step.child])) return true
+    } else if (step.type === 'parallel' && step.children) {
+      if (hasInlineSteps(step.children)) return true
+    }
+  }
+  return false
+}
 
 /**
- * Scan for workflow.do() and workflow.sleep() calls to extract workflow steps
+ * Recursively collect all RPC names from workflow steps
+ */
+function collectInvokedRPCs(
+  steps: WorkflowStepMeta[],
+  rpcs: Set<string>
+): void {
+  for (const step of steps) {
+    if (step.type === 'rpc' && step.rpcName) {
+      rpcs.add(step.rpcName)
+    } else if (step.type === 'branch') {
+      for (const branch of step.branches) {
+        collectInvokedRPCs(branch.steps, rpcs)
+      }
+      if (step.elseSteps) collectInvokedRPCs(step.elseSteps, rpcs)
+    } else if (step.type === 'switch' && step.cases) {
+      for (const c of step.cases) {
+        if (c.steps) collectInvokedRPCs(c.steps, rpcs)
+      }
+      if (step.defaultSteps) collectInvokedRPCs(step.defaultSteps, rpcs)
+    } else if (step.type === 'fanout' && step.child) {
+      collectInvokedRPCs([step.child], rpcs)
+    } else if (step.type === 'parallel' && step.children) {
+      collectInvokedRPCs(step.children, rpcs)
+    }
+  }
+}
+
+/**
+ * Scan for workflow.do(), workflow.sleep(), and workflow.cancel() calls to extract workflow steps
  */
 function getWorkflowInvocations(
   node: ts.Node,
@@ -37,7 +83,7 @@ function getWorkflowInvocations(
     const { name } = node
 
     // Check if this is accessing 'do' or 'sleep' property
-    if (name.text === 'do' || name.text === 'sleep') {
+    if (name.text === 'do' || name.text === 'sleep' || name.text === 'cancel') {
       // Check if the parent is a call expression
       const parent = node.parent
       if (ts.isCallExpression(parent) && parent.expression === node) {
@@ -62,7 +108,6 @@ function getWorkflowInvocations(
               type: 'rpc',
               stepName,
               rpcName,
-              description,
             })
             state.rpc.invokedFunctions.add(rpcName)
           } else if (isFunctionLike(secondArg)) {
@@ -86,18 +131,20 @@ function getWorkflowInvocations(
             stepName: stepName || '<dynamic>',
             duration: duration || '<dynamic>',
           })
+        } else if (name.text === 'cancel') {
+          // workflow.cancel(reason?)
+          steps.push({
+            type: 'cancel',
+          })
         }
       }
     }
   }
 
-  // Don't recurse into nested functions - only look at top-level workflow calls
+  // Recurse into children, including arrow functions (for Promise.all callbacks)
+  // but skip function declarations (which would be separate functions)
   ts.forEachChild(node, (child) => {
-    if (
-      ts.isFunctionDeclaration(child) ||
-      ts.isFunctionExpression(child) ||
-      ts.isArrowFunction(child)
-    ) {
+    if (ts.isFunctionDeclaration(child)) {
       return
     }
     getWorkflowInvocations(child, checker, state, workflowName, steps)
@@ -105,43 +152,10 @@ function getWorkflowInvocations(
 }
 
 /**
- * Extract description from options object
- */
-function extractDescription(
-  optionsNode: ts.Node | undefined,
-  checker: ts.TypeChecker
-): string | null {
-  if (!optionsNode || !ts.isObjectLiteralExpression(optionsNode)) {
-    return null
-  }
-  return extractPropertyString(optionsNode, 'description', checker)
-}
-
-/**
- * Extract duration value (number or string)
- */
-function extractDuration(
-  node: ts.Node,
-  checker: ts.TypeChecker
-): string | number | null {
-  const numValue = extractNumberLiteral(node)
-  if (numValue !== null) {
-    return numValue
-  }
-  return extractStringLiteral(node, checker)
-}
-
-/**
- * Inspector for wireWorkflow() calls
+ * Inspector for pikkuWorkflow() and pikkuSimpleWorkflow() calls
  * Detects workflow registration and extracts metadata
  */
-export const addWorkflow: AddWiring = (
-  logger,
-  node,
-  checker,
-  state,
-  options
-) => {
+export const addWorkflow: AddWiring = (logger, node, checker, state) => {
   if (!ts.isCallExpression(node)) {
     return
   }
@@ -150,8 +164,16 @@ export const addWorkflow: AddWiring = (
   const firstArg = args[0]
   const expression = node.expression
 
-  // Check if the call is to wireWorkflow
-  if (!ts.isIdentifier(expression) || expression.text !== 'wireWorkflow') {
+  if (!ts.isIdentifier(expression)) {
+    return
+  }
+
+  let wrapperType: 'dsl' | 'regular' | null = null
+  if (expression.text === 'pikkuWorkflowFunc') {
+    wrapperType = 'dsl'
+  } else if (expression.text === 'pikkuWorkflowComplexFunc') {
+    wrapperType = 'regular'
+  } else {
     return
   }
 
@@ -159,73 +181,147 @@ export const addWorkflow: AddWiring = (
     return
   }
 
-  if (ts.isObjectLiteralExpression(firstArg)) {
-    const obj = firstArg
-
-    const workflowName = getPropertyValue(obj, 'name') as string | null
-    const description = getPropertyValue(obj, 'description') as
-      | string
-      | undefined
-    const docs = (getPropertyValue(obj, 'docs') as PikkuDocs) || undefined
-    const tags = getPropertyTags(obj, 'Workflow', workflowName, logger)
-
-    // --- find the referenced function ---
-    const funcInitializer = getPropertyAssignmentInitializer(
-      obj,
-      'func',
-      true,
-      checker
+  // Extract workflow name and metadata using same logic as add-functions
+  const { pikkuFuncName, name, exportedName } = extractFunctionName(
+    node,
+    checker,
+    state.rootDir
+  )
+
+  const workflowName = exportedName || name
+
+  if (!workflowName) {
+    logger.critical(
+      ErrorCode.MISSING_NAME,
+      `Could not determine workflow name from export.`
     )
+    return
+  }
 
-    if (!workflowName) {
-      logger.critical(
-        ErrorCode.MISSING_NAME,
-        `Wasn't able to determine 'name' property for workflow wiring.`
-      )
-      return
-    }
+  // Extract the function node (either direct function or from config.func)
+  const { funcNode, resolvedFunc } = extractFunctionNode(firstArg, checker)
 
-    if (!funcInitializer) {
-      logger.critical(
-        ErrorCode.MISSING_FUNC,
-        `No valid 'func' property for workflow '${workflowName}'.`
-      )
-      return
-    }
+  // Extract metadata if using object form
+  let tags: string[] | undefined
+  let summary: string | undefined
+  let description: string | undefined
+  let errors: string[] | undefined
 
-    const pikkuFuncName = extractFunctionName(
-      funcInitializer,
-      checker,
-      state.rootDir
-    ).pikkuFuncName
+  if (ts.isObjectLiteralExpression(firstArg)) {
+    const metadata = getCommonWireMetaData(
+      firstArg,
+      'Workflow',
+      workflowName,
+      logger
+    )
+    tags = metadata.tags
+    summary = metadata.summary
+    description = metadata.description
+    errors = metadata.errors
+  }
 
-    // --- resolve middleware ---
-    const middleware = resolveMiddleware(state, obj, tags, checker)
+  // Validate that we got a valid function
+  if (
+    ts.isObjectLiteralExpression(firstArg) &&
+    (!funcNode || funcNode === firstArg)
+  ) {
+    logger.critical(
+      ErrorCode.MISSING_FUNC,
+      `No valid 'func' property for workflow '${workflowName}'.`
+    )
+    return
+  }
 
-    // --- track used functions/middleware for service aggregation ---
-    state.serviceAggregation.usedFunctions.add(pikkuFuncName)
-    extractWireNames(middleware).forEach((name) =>
-      state.serviceAggregation.usedMiddleware.add(name)
+  if (!resolvedFunc) {
+    logger.critical(
+      ErrorCode.MISSING_FUNC,
+      `Could not resolve workflow function for '${workflowName}'.`
     )
+    return
+  }
 
-    state.workflows.files.add(node.getSourceFile().fileName)
+  // Track workflow file for wiring generation
+  if (exportedName) {
+    state.workflows.files.set(pikkuFuncName, {
+      path: node.getSourceFile().fileName,
+      exportedName,
+    })
+  }
 
-    // Extract workflow steps from function body
-    // Resolve the identifier to the actual function declaration
-    const resolvedFunc = resolveFunctionDeclaration(funcInitializer, checker)
-    const steps: WorkflowStepMeta[] = []
-    if (resolvedFunc) {
-      getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps)
+  let steps: WorkflowStepMeta[] = []
+  let context: WorkflowContext | undefined = undefined
+  let dsl: boolean | undefined = undefined
+
+  // Try DSL workflow extraction first
+  // Pass the whole CallExpression node so findWorkflowFunction can find the arrow function
+  const result = extractDSLWorkflow(node, checker)
+
+  if (result.status === 'ok' && result.steps) {
+    // Extraction succeeded
+    steps = result.steps
+    context = result.context
+
+    // Check if workflow contains inline steps (non-serializable)
+    if (hasInlineSteps(steps)) {
+      if (wrapperType === 'dsl') {
+        // pikkuWorkflowFunc should not have inline steps
+        logger.critical(
+          ErrorCode.INVALID_DSL_WORKFLOW,
+          `Workflow '${workflowName}' uses pikkuWorkflowFunc but contains inline steps which are not allowed in DSL workflows. Use pikkuWorkflowComplexFunc instead.`
+        )
+        return
+      }
+      // pikkuWorkflowComplexFunc with inline steps is marked as non-dsl
+      dsl = false
+    } else {
+      // pikkuWorkflowComplexFunc is always non-dsl, pikkuWorkflowFunc is dsl
+      dsl = wrapperType === 'dsl'
     }
 
-    state.workflows.meta[workflowName] = {
-      pikkuFuncName,
-      workflowName,
-      description,
-      docs,
-      tags,
-      middleware,
-      steps,
+    // Collect all invoked RPCs from workflow steps
+    const rpcs = new Set<string>()
+    collectInvokedRPCs(steps, rpcs)
+    for (const rpc of rpcs) {
+      state.rpc.invokedFunctions.add(rpc)
+    }
+  } else {
+    // DSL extraction failed
+    if (wrapperType === 'dsl') {
+      // For pikkuWorkflowFunc, this is a critical error
+      // But still track RPC invocations for function registration
+      getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps)
+      logger.critical(
+        ErrorCode.INVALID_DSL_WORKFLOW,
+        `Workflow '${workflowName}' uses pikkuWorkflowFunc but does not conform to DSL workflow rules:\n${result.reason || 'Unknown error'}`
+      )
+      return
+    } else {
+      // For pikkuWorkflowComplexFunc, fall back to basic extraction
+      logger.debug(
+        `Workflow '${workflowName}' could not be extracted as DSL workflow: ${result.reason || 'Unknown error'}. Falling back to basic extraction.`
+      )
+      dsl = false
     }
   }
+
+  /**
+   * For non-dsl workflows or pikkuWorkflowComplexFunc, run basic extraction
+   * to ensure all RPC invocations are tracked for function registration.
+   * This catches RPCs in Promise.all callbacks and other patterns DSL can't extract.
+   */
+  if (!dsl || wrapperType === 'regular') {
+    getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps)
+  }
+
+  state.workflows.meta[workflowName] = {
+    pikkuFuncName,
+    workflowName,
+    steps,
+    context,
+    dsl,
+    summary,
+    description,
+    errors,
+    tags,
+  }
 }

package/src/error-codes.ts

@@ -11,6 +11,7 @@ export enum ErrorCode {
   // Validation errors
   MISSING_NAME = 'PKU111',
   MISSING_DESCRIPTION = 'PKU123',
+  INVALID_VALUE = 'PKU124',
   MISSING_URI = 'PKU220',
   MISSING_FUNC = 'PKU236',
   INVALID_TAGS_TYPE = 'PKU247',
@@ -21,6 +22,7 @@ export enum ErrorCode {
   CLI_CLIENTSIDE_RENDERER_HAS_SERVICES = 'PKU672',
   DYNAMIC_STEP_NAME = 'PKU529',
   WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED = 'PKU600',
+  INVALID_DSL_WORKFLOW = 'PKU641',
 
   // Configuration errors
   CONFIG_TYPE_NOT_FOUND = 'PKU426',
@@ -28,6 +30,7 @@ export enum ErrorCode {
   SCHEMA_NO_ROOT = 'PKU431',
   SCHEMA_GENERATION_ERROR = 'PKU456',
   SCHEMA_LOAD_ERROR = 'PKU488',
+  INLINE_ZOD_SCHEMA = 'PKU489',
 
   // Function errors
   FUNCTION_METADATA_NOT_FOUND = 'PKU559',

package/src/index.ts

@@ -14,3 +14,15 @@ export {
 } from './utils/serialize-inspector-state.js'
 export type { SerializableInspectorState } from './utils/serialize-inspector-state.js'
 export { filterInspectorState } from './utils/filter-inspector-state.js'
+export { writeAllServiceMetadata } from './utils/write-service-metadata.js'
+export type { ServiceMetadata } from './utils/extract-service-metadata.js'
+export {
+  convertAllDslToGraphs,
+  convertDslToGraph,
+} from './utils/workflow/graph/convert-dsl-to-graph.js'
+export {
+  deserializeDslWorkflow,
+  deserializeGraphWorkflow,
+  deserializeAllDslWorkflows,
+} from './utils/workflow/dsl/deserialize-dsl-workflow.js'
+export type { SerializedWorkflowGraph } from './utils/workflow/graph/workflow-graph.types.js'

package/src/inspector.ts

@@ -5,7 +5,10 @@ import { TypesMap } from './types-map.js'
 import { InspectorState, InspectorLogger, InspectorOptions } from './types.js'
 import { getFilesAndMethods } from './utils/get-files-and-methods.js'
 import { findCommonAncestor } from './utils/find-root-dir.js'
-import { aggregateRequiredServices } from './utils/post-process.js'
+import {
+  aggregateRequiredServices,
+  extractServiceInterfaceMetadata,
+} from './utils/post-process.js'
 
 /**
  * Creates an initial/empty inspector state with all required properties initialized
@@ -16,16 +19,17 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
   return {
     rootDir,
     singletonServicesTypeImportMap: new Map(),
-    sessionServicesTypeImportMap: new Map(),
+    wireServicesTypeImportMap: new Map(),
     userSessionTypeImportMap: new Map(),
     configTypeImportMap: new Map(),
     singletonServicesFactories: new Map(),
-    sessionServicesFactories: new Map(),
-    sessionServicesMeta: new Map(),
+    wireServicesFactories: new Map(),
+    wireServicesMeta: new Map(),
     configFactories: new Map(),
     filesAndMethods: {},
     filesAndMethodsErrors: new Map(),
     typesLookup: new Map(),
+    zodLookup: new Map(),
     functions: {
       typesMap: new TypesMap(),
       meta: {},
@@ -60,7 +64,9 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
     },
     workflows: {
       meta: {},
-      files: new Set(),
+      files: new Map(),
+      graphMeta: {},
+      graphFiles: new Map(),
     },
     rpc: {
       internalMeta: {},
@@ -68,6 +74,7 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
       exposedMeta: {},
       exposedFiles: new Map(),
       invokedFunctions: new Set(),
+      usedExternalPackages: new Set(),
     },
     mcpEndpoints: {
       resourcesMeta: {},
@@ -82,6 +89,14 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
       },
       files: new Set(),
     },
+    forgeNodes: {
+      meta: {},
+      files: new Set(),
+    },
+    forgeCredentials: {
+      meta: {},
+      files: new Set(),
+    },
     middleware: {
       meta: {},
       tagMiddleware: new Map(),
@@ -96,8 +111,9 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
       usedMiddleware: new Set(),
       usedPermissions: new Set(),
       allSingletonServices: [],
-      allSessionServices: [],
+      allWireServices: [],
     },
+    serviceMetadata: [],
   }
 }
 
@@ -127,15 +143,19 @@ export const inspect = (
     `Got type checker in ${(performance.now() - startChecker).toFixed(2)}ms`
   )
 
+  // Use provided rootDir or infer from source files
+  const rootDir = options.rootDir || findCommonAncestor(routeFiles)
+
   const startSourceFiles = performance.now()
-  const sourceFiles = program.getSourceFiles()
+  // Filter source files to only include files within the project rootDir
+  // This prevents picking up types from external packages (including workspace symlinks)
+  const sourceFiles = program
+    .getSourceFiles()
+    .filter((sf) => sf.fileName.startsWith(rootDir))
   logger.debug(
     `Got source files in ${(performance.now() - startSourceFiles).toFixed(2)}ms`
   )
 
-  // Infer root directory from source files
-  const rootDir = findCommonAncestor(routeFiles)
-
   const state = getInitialInspectorState(rootDir)
 
   // First sweep: add all functions
@@ -177,6 +197,12 @@ export const inspect = (
     logger.debug(
       `Aggregate required services completed in ${(performance.now() - startAggregate).toFixed(2)}ms`
     )
+
+    const startServiceMeta = performance.now()
+    extractServiceInterfaceMetadata(state, checker)
+    logger.debug(
+      `Extract service metadata completed in ${(performance.now() - startServiceMeta).toFixed(2)}ms`
+    )
   }
 
   return state

package/src/types.ts

@@ -6,9 +6,11 @@ import { QueueWorkersMeta } from '@pikku/core/queue'
 import { WorkflowsMeta } from '@pikku/core/workflow'
 import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp'
 import { CLIMeta } from '@pikku/core/cli'
+import { ForgeNodesMeta, ForgeCredentialsMeta } from '@pikku/core/forge-node'
 import { TypesMap } from './types-map.js'
 import { FunctionsMeta, FunctionServicesMeta } from '@pikku/core'
 import { ErrorCode } from './error-codes.js'
+import type { SerializedWorkflowGraphs } from './utils/workflow/graph/workflow-graph.types.js'
 
 export type PathToNameAndType = Map<
   string,
@@ -56,6 +58,14 @@ export interface InspectorHTTPState {
   routePermissions: Map<string, PermissionGroupMeta>
 }
 
+/**
+ * Zod schema reference for deferred conversion to JSON Schema at build time
+ */
+export interface ZodSchemaRef {
+  variableName: string
+  sourceFile: string
+}
+
 export interface InspectorFunctionState {
   typesMap: TypesMap
   meta: FunctionsMeta
@@ -116,11 +126,13 @@ export type InspectorFilters = {
 
 export type InspectorOptions = Partial<{
   setupOnly: boolean
+  /** Project root directory - used to filter out external package files */
+  rootDir: string
   types: Partial<{
     configFileType: string
     userSessionType: string
     singletonServicesFactoryType: string
-    sessionServicesFactoryType: string
+    wireServicesFactoryType: string
   }>
 }>
 
@@ -147,7 +159,7 @@ export interface InspectorFilesAndMethods {
     type: string
     typePath: string
   }
-  sessionServicesType?: {
+  wireServicesType?: {
     file: string
     variable: string
     type: string
@@ -177,7 +189,7 @@ export interface InspectorFilesAndMethods {
     type: string
     typePath: string
   }
-  sessionServicesFactory?: {
+  wireServicesFactory?: {
     file: string
     variable: string
     type: string
@@ -188,16 +200,17 @@ export interface InspectorFilesAndMethods {
 export interface InspectorState {
   rootDir: string // Root directory inferred from source files
   singletonServicesTypeImportMap: PathToNameAndType
-  sessionServicesTypeImportMap: PathToNameAndType
+  wireServicesTypeImportMap: PathToNameAndType
   userSessionTypeImportMap: PathToNameAndType
   configTypeImportMap: PathToNameAndType
   singletonServicesFactories: PathToNameAndType
-  sessionServicesFactories: PathToNameAndType
-  sessionServicesMeta: Map<string, string[]> // variable name -> singleton services consumed
+  wireServicesFactories: PathToNameAndType
+  wireServicesMeta: Map<string, string[]> // variable name -> singleton services consumed
   configFactories: PathToNameAndType
   filesAndMethods: InspectorFilesAndMethods
   filesAndMethodsErrors: Map<string, PathToNameAndType>
   typesLookup: Map<string, ts.Type[]> // Lookup for types by name (e.g., function input types, Config type)
+  zodLookup: Map<string, ZodSchemaRef> // Lookup for Zod schemas by name for deferred JSON Schema conversion
   http: InspectorHTTPState
   functions: InspectorFunctionState
   channels: InspectorChannelState
@@ -211,14 +224,17 @@ export interface InspectorState {
   }
   workflows: {
     meta: WorkflowsMeta
-    files: Set<string>
+    files: Map<string, { path: string; exportedName: string }>
+    graphMeta: SerializedWorkflowGraphs
+    graphFiles: Map<string, { path: string; exportedName: string }>
   }
   rpc: {
     internalMeta: Record<string, string>
     internalFiles: Map<string, { path: string; exportedName: string }>
     exposedMeta: Record<string, string>
     exposedFiles: Map<string, { path: string; exportedName: string }>
-    invokedFunctions: Set<string> // Track functions called via rpc.invoke()
+    invokedFunctions: Set<string>
+    usedExternalPackages: Set<string>
   }
   mcpEndpoints: {
     resourcesMeta: MCPResourceMeta
@@ -230,6 +246,14 @@ export interface InspectorState {
     meta: CLIMeta
     files: Set<string>
   }
+  forgeNodes: {
+    meta: ForgeNodesMeta
+    files: Set<string>
+  }
+  forgeCredentials: {
+    meta: ForgeCredentialsMeta
+    files: Set<string>
+  }
   middleware: InspectorMiddlewareState
   permissions: InspectorPermissionState
   serviceAggregation: {
@@ -238,6 +262,16 @@ export interface InspectorState {
     usedMiddleware: Set<string> // Middleware names used by wired functions
     usedPermissions: Set<string> // Permission names used by wired functions
     allSingletonServices: string[] // All services available in SingletonServices type
-    allSessionServices: string[] // All services available in Services type (excluding SingletonServices)
+    allWireServices: string[] // All services available in Services type (excluding SingletonServices)
   }
+  serviceMetadata: Array<{
+    name: string
+    summary: string
+    description: string
+    package: string
+    path: string
+    version: string
+    interface: string
+    expandedProperties: Record<string, string>
+  }>
 }