@pikku/inspector 0.12.34 → 0.12.36

package/src/utils/filter-inspector-state.ts

@@ -468,6 +468,11 @@ export function filterInspectorState(
           filteredState.serviceAggregation.usedFunctions.add(
             routeMeta.pikkuFuncId
           )
+          if (routeMeta.refTarget) {
+            filteredState.serviceAggregation.usedFunctions.add(
+              routeMeta.refTarget
+            )
+          }
           // For workflow/agent routes, also add the base name
           // so the workflow/agent definition survives pruning
           const colonIdx = routeMeta.pikkuFuncId.indexOf(':')
@@ -1105,6 +1110,57 @@ export function filterInspectorState(
     filteredState.serviceAggregation.requiredServices.add('queueService')
   }
 
+  if ((filteredState.rpc.wireAddonDeclarations?.size ?? 0) > 0) {
+    const referencedIds = new Set<string>(
+      filteredState.serviceAggregation.usedFunctions
+    )
+    const keptFiles = new Set<string>()
+    for (const funcId of filteredState.serviceAggregation.usedFunctions) {
+      const file = filteredState.functions.files.get(funcId)
+      if (file?.path) keptFiles.add(file.path)
+    }
+    for (const [file, invoked] of state.rpc.invokedFunctionsByFile ??
+      new Map<string, Set<string>>()) {
+      if (!keptFiles.has(file)) continue
+      for (const id of invoked) {
+        referencedIds.add(id)
+        if (id.includes(':')) {
+          filteredState.serviceAggregation.usedFunctions.add(id)
+        }
+      }
+    }
+    for (const toolMeta of Object.values(
+      filteredState.mcpEndpoints?.toolsMeta ?? {}
+    ) as Array<{ pikkuFuncId?: string }>) {
+      if (toolMeta.pikkuFuncId) referencedIds.add(toolMeta.pikkuFuncId)
+    }
+    for (const agentMeta of Object.values(
+      filteredState.agents?.agentsMeta ?? {}
+    ) as Array<{ tools?: string[] }>) {
+      for (const tool of agentMeta.tools ?? []) referencedIds.add(tool)
+    }
+    const keptNamespaces = new Set<string>()
+    for (const namespace of filteredState.rpc.wireAddonDeclarations.keys()) {
+      const prefix = `${namespace}:`
+      for (const id of referencedIds) {
+        if (id.startsWith(prefix)) {
+          keptNamespaces.add(namespace)
+          break
+        }
+      }
+    }
+    filteredState.rpc.wireAddonDeclarations = new Map(
+      [...filteredState.rpc.wireAddonDeclarations].filter(([namespace]) =>
+        keptNamespaces.has(namespace)
+      )
+    )
+    filteredState.rpc.usedAddons = new Set(
+      [...filteredState.rpc.usedAddons].filter((namespace) =>
+        keptNamespaces.has(namespace)
+      )
+    )
+  }
+
   // Recalculate requiredServices based on filtered functions/middleware/permissions
   // Need to cast to InspectorState temporarily for aggregateRequiredServices
   const stateForAggregation = filteredState as InspectorState

package/src/utils/load-addon-functions-meta.ts

@@ -200,6 +200,7 @@ export async function loadAddonFunctionsMeta(
         // No variables meta — that's fine
       }
       // Load addon serverlessIncompatible service names from pikku-addon-meta.gen.json
+      let loadedParentServices = false
       try {
         const addonMetaPath = require.resolve(
           `${decl.package}/.pikku/console/pikku-addon-meta.gen.json`
@@ -218,29 +219,38 @@ export async function loadAddonFunctionsMeta(
             `Addon '${namespace}' marks [${addonMeta.serverlessIncompatible.join(', ')}] as serverless-incompatible`
           )
         }
-      } catch {
-        // No addon meta or no serverlessIncompatible declared — that's fine
-      }
-
-      // Load addon required parent services from pikku-services.gen
-      try {
-        const servicesGenPath = require.resolve(
-          `${decl.package}/.pikku/pikku-services.gen.js`
-        )
-        const servicesModule = await import(servicesGenPath)
         if (
-          servicesModule.requiredParentServices &&
-          Array.isArray(servicesModule.requiredParentServices)
+          Array.isArray(addonMeta.requiredParentServices) &&
+          addonMeta.requiredParentServices.length > 0
         ) {
-          for (const service of servicesModule.requiredParentServices) {
+          for (const service of addonMeta.requiredParentServices) {
             state.addonRequiredParentServices.push(service)
           }
+          loadedParentServices = true
           logger.debug(
-            `Loaded ${servicesModule.requiredParentServices.length} required parent services for '${namespace}' from ${decl.package}`
+            `Loaded ${addonMeta.requiredParentServices.length} required parent services for '${namespace}' from addon meta`
           )
         }
-      } catch {
-        // No services gen — addon may not have requiredParentServices
+      } catch {}
+
+      if (!loadedParentServices) {
+        try {
+          const servicesGenPath = require.resolve(
+            `${decl.package}/.pikku/pikku-services.gen.js`
+          )
+          const servicesModule = await import(servicesGenPath)
+          if (
+            servicesModule.requiredParentServices &&
+            Array.isArray(servicesModule.requiredParentServices)
+          ) {
+            for (const service of servicesModule.requiredParentServices) {
+              state.addonRequiredParentServices.push(service)
+            }
+            logger.debug(
+              `Loaded ${servicesModule.requiredParentServices.length} required parent services for '${namespace}' from ${decl.package}`
+            )
+          }
+        } catch {}
       }
 
       try {

package/src/utils/post-process.test.ts

@@ -0,0 +1,254 @@
+import { strict as assert } from 'assert'
+import { describe, test } from 'node:test'
+import { aggregateRequiredServices } from './post-process.js'
+import type { InspectorState } from '../types.js'
+
+function makeState(
+  overrides: {
+    usedFunctions?: string[]
+    functionsMeta?: Record<string, any>
+    addonFunctions?: Record<string, Record<string, any>>
+    addonRequiredParentServices?: string[]
+  } = {}
+): Omit<InspectorState, 'typesLookup'> {
+  return {
+    serviceAggregation: {
+      requiredServices: new Set<string>(),
+      usedFunctions: new Set(overrides.usedFunctions ?? []),
+      usedMiddleware: new Set<string>(),
+      usedPermissions: new Set<string>(),
+      allSingletonServices: [],
+      allWireServices: [],
+    },
+    functions: { meta: overrides.functionsMeta ?? {} },
+    middleware: { definitions: {}, tagMiddleware: new Map() },
+    permissions: { definitions: {}, tagPermissions: new Map() },
+    http: {
+      meta: {
+        get: {},
+        post: {},
+        put: {},
+        patch: {},
+        delete: {},
+        head: {},
+        options: {},
+      },
+      routeMiddleware: new Map(),
+      routePermissions: new Map(),
+    },
+    channels: { meta: {} },
+    queueWorkers: { meta: {} },
+    scheduledTasks: { meta: {} },
+    mcpEndpoints: { toolsMeta: {}, promptsMeta: {}, resourcesMeta: {} },
+    agents: { agentsMeta: {} },
+    workflows: { meta: {}, graphMeta: {} },
+    wireServicesMeta: new Map(),
+    rpc: { internalMeta: {}, exposedMeta: {} },
+    addonFunctions: overrides.addonFunctions ?? {},
+    addonRequiredParentServices: overrides.addonRequiredParentServices ?? [],
+  } as unknown as Omit<InspectorState, 'typesLookup'>
+}
+
+const CONSOLE_PARENT_SERVICES = [
+  'metaService',
+  'aiAgentRunner',
+  'deploymentService',
+  'credentialService',
+]
+
+describe('aggregateRequiredServices — per-function addon services', () => {
+  test('a used addon function adds only its own parent services', () => {
+    const state = makeState({
+      usedFunctions: ['console:getSchema'],
+      addonFunctions: {
+        console: {
+          getSchema: {
+            services: { optimized: true, services: ['metaService'] },
+          },
+          runAgent: {
+            services: {
+              optimized: true,
+              services: ['aiAgentRunner', 'deploymentService'],
+            },
+          },
+        },
+      },
+      addonRequiredParentServices: CONSOLE_PARENT_SERVICES,
+    })
+    aggregateRequiredServices(state)
+    const required = state.serviceAggregation.requiredServices
+    assert.ok(required.has('metaService'))
+    assert.ok(!required.has('aiAgentRunner'))
+    assert.ok(!required.has('deploymentService'))
+    assert.ok(!required.has('credentialService'))
+  })
+
+  test('an addon-created service falls back to the full parent blanket', () => {
+    const state = makeState({
+      usedFunctions: ['console:editCode'],
+      addonFunctions: {
+        console: {
+          editCode: {
+            services: {
+              optimized: true,
+              services: ['codeEditService', 'metaService'],
+            },
+          },
+        },
+      },
+      addonRequiredParentServices: CONSOLE_PARENT_SERVICES,
+    })
+    aggregateRequiredServices(state)
+    const required = state.serviceAggregation.requiredServices
+    for (const service of CONSOLE_PARENT_SERVICES) {
+      assert.ok(required.has(service), `expected blanket to add ${service}`)
+    }
+  })
+
+  test('missing services meta (old addon build) falls back to the blanket', () => {
+    const state = makeState({
+      usedFunctions: ['console:getSchema'],
+      addonFunctions: { console: { getSchema: {} } },
+      addonRequiredParentServices: CONSOLE_PARENT_SERVICES,
+    })
+    aggregateRequiredServices(state)
+    const required = state.serviceAggregation.requiredServices
+    for (const service of CONSOLE_PARENT_SERVICES) {
+      assert.ok(required.has(service), `expected blanket to add ${service}`)
+    }
+  })
+
+  test('a bare project function colliding with an addon function name adds nothing', () => {
+    const state = makeState({
+      usedFunctions: ['getAgentThreads'],
+      functionsMeta: {
+        getAgentThreads: {
+          services: { optimized: true, services: ['kysely'] },
+        },
+      },
+      addonFunctions: {
+        console: {
+          getAgentThreads: {
+            services: { optimized: true, services: ['metaService'] },
+          },
+        },
+      },
+      addonRequiredParentServices: CONSOLE_PARENT_SERVICES,
+    })
+    aggregateRequiredServices(state)
+    const required = state.serviceAggregation.requiredServices
+    assert.ok(required.has('kysely'))
+    assert.ok(!required.has('metaService'))
+    assert.ok(!required.has('aiAgentRunner'))
+  })
+
+  test('no used addon functions adds no parent services', () => {
+    const state = makeState({
+      usedFunctions: ['listTasks'],
+      functionsMeta: {
+        listTasks: { services: { optimized: true, services: ['kysely'] } },
+      },
+      addonFunctions: {
+        console: {
+          getSchema: {
+            services: { optimized: true, services: ['metaService'] },
+          },
+        },
+      },
+      addonRequiredParentServices: CONSOLE_PARENT_SERVICES,
+    })
+    aggregateRequiredServices(state)
+    const required = state.serviceAggregation.requiredServices
+    assert.ok(!required.has('metaService'))
+    assert.ok(!required.has('aiAgentRunner'))
+  })
+
+  test('internal services in addon function meta never force the blanket', () => {
+    const state = makeState({
+      usedFunctions: ['console:getSchema'],
+      addonFunctions: {
+        console: {
+          getSchema: {
+            services: {
+              optimized: true,
+              services: ['metaService', 'rpc', 'channel'],
+            },
+          },
+        },
+      },
+      addonRequiredParentServices: CONSOLE_PARENT_SERVICES,
+    })
+    aggregateRequiredServices(state)
+    const required = state.serviceAggregation.requiredServices
+    assert.ok(required.has('metaService'))
+    assert.ok(!required.has('aiAgentRunner'))
+    assert.ok(!required.has('rpc'))
+  })
+
+  test('default framework services in addon function meta never force the blanket', () => {
+    const state = makeState({
+      usedFunctions: ['ext:goodbye'],
+      addonFunctions: {
+        ext: {
+          goodbye: {
+            services: { optimized: true, services: ['logger', 'config'] },
+          },
+        },
+      },
+      addonRequiredParentServices: ['greetingStore', 'auditSink'],
+    })
+    aggregateRequiredServices(state)
+    const required = state.serviceAggregation.requiredServices
+    assert.ok(!required.has('greetingStore'))
+    assert.ok(!required.has('auditSink'))
+  })
+
+  test('a ref()-wired route (inline id + namespaced target) aggregates the target services', () => {
+    const state = makeState({
+      usedFunctions: [
+        'http:get:/function-tests/stream',
+        'console:streamFunctionTests',
+      ],
+      functionsMeta: {
+        'http:get:/function-tests/stream': {
+          services: { optimized: false, services: [] },
+        },
+      },
+      addonFunctions: {
+        console: {
+          streamFunctionTests: {
+            services: { optimized: true, services: ['metaService'] },
+          },
+        },
+      },
+      addonRequiredParentServices: CONSOLE_PARENT_SERVICES,
+    })
+    aggregateRequiredServices(state)
+    const required = state.serviceAggregation.requiredServices
+    assert.ok(required.has('metaService'))
+    assert.ok(!required.has('aiAgentRunner'))
+  })
+
+  test('multiple used addon functions union their parent services', () => {
+    const state = makeState({
+      usedFunctions: ['console:getSchema', 'console:runAgent'],
+      addonFunctions: {
+        console: {
+          getSchema: {
+            services: { optimized: true, services: ['metaService'] },
+          },
+          runAgent: {
+            services: { optimized: true, services: ['aiAgentRunner'] },
+          },
+        },
+      },
+      addonRequiredParentServices: CONSOLE_PARENT_SERVICES,
+    })
+    aggregateRequiredServices(state)
+    const required = state.serviceAggregation.requiredServices
+    assert.ok(required.has('metaService'))
+    assert.ok(required.has('aiAgentRunner'))
+    assert.ok(!required.has('deploymentService'))
+    assert.ok(!required.has('credentialService'))
+  })
+})

package/src/utils/post-process.ts

@@ -325,20 +325,47 @@ export function aggregateRequiredServices(
   }
 
   // 7. Services that consumed addons need from the parent project.
-  // These are required ONLY by units that actually deploy an addon function;
-  // a unit that merely calls the addon over RPC (or never touches it) must not
-  // carry them, or every per-unit bundle would over-include the addon's
-  // parent-service dependencies (e.g. aiAgentRunner, deploymentService) and
-  // defeat per-unit tree-shaking.
-  const addonFuncIds = new Set<string>()
-  for (const fns of Object.values(state.addonFunctions ?? {})) {
-    for (const id of Object.keys(fns)) addonFuncIds.add(id)
-  }
-  const unitDeploysAddonFn = [...usedFunctions].some((fn) =>
-    addonFuncIds.has(fn)
-  )
-  if (unitDeploysAddonFn) {
-    for (const service of state.addonRequiredParentServices ?? []) {
+  const addonFnServices = new Map<string, string[] | undefined>()
+  for (const [namespace, fns] of Object.entries(state.addonFunctions ?? {})) {
+    for (const [id, meta] of Object.entries(fns)) {
+      addonFnServices.set(
+        `${namespace}:${id}`,
+        (meta as { services?: FunctionServicesMeta })?.services?.services
+      )
+    }
+  }
+  const parentDeclared = state.addonRequiredParentServices ?? []
+  const parentDeclaredSet = new Set(parentDeclared)
+  const defaultServices = new Set([
+    'config',
+    'logger',
+    'variables',
+    'schema',
+    'secrets',
+  ])
+  let usesAddonFn = false
+  let addonFactoryNeeded = false
+  for (const funcId of usedFunctions) {
+    if (!addonFnServices.has(funcId)) continue
+    usesAddonFn = true
+    const services = addonFnServices.get(funcId)
+    if (!services) {
+      addonFactoryNeeded = true
+      continue
+    }
+    for (const service of services) {
+      if (parentDeclaredSet.has(service)) {
+        requiredServices.add(service)
+      } else if (
+        !internalServices.has(service) &&
+        !defaultServices.has(service)
+      ) {
+        addonFactoryNeeded = true
+      }
+    }
+  }
+  if (usesAddonFn && addonFactoryNeeded) {
+    for (const service of parentDeclared) {
       requiredServices.add(service)
     }
   }

package/src/utils/serialize-inspector-state.ts

@@ -155,6 +155,7 @@ export interface SerializableInspectorState {
     exposedMeta: InspectorState['rpc']['exposedMeta']
     exposedFiles: Array<[string, { path: string; exportedName: string }]>
     invokedFunctions: string[]
+    invokedFunctionsByFile?: Array<[string, string[]]>
     usedAddons: string[]
     wireAddonDeclarations: Array<
       [
@@ -379,6 +380,11 @@ export function serializeInspectorState(
       exposedMeta: state.rpc.exposedMeta,
       exposedFiles: Array.from(state.rpc.exposedFiles.entries()),
       invokedFunctions: Array.from(state.rpc.invokedFunctions),
+      invokedFunctionsByFile: Array.from(
+        (
+          state.rpc.invokedFunctionsByFile ?? new Map<string, Set<string>>()
+        ).entries()
+      ).map(([file, fns]): [string, string[]] => [file, Array.from(fns)]),
       usedAddons: Array.from(state.rpc.usedAddons),
       wireAddonDeclarations: Array.from(
         state.rpc.wireAddonDeclarations.entries()
@@ -565,6 +571,11 @@ export function deserializeInspectorState(
       exposedMeta: data.rpc.exposedMeta,
       exposedFiles: new Map(data.rpc.exposedFiles),
       invokedFunctions: new Set(data.rpc.invokedFunctions),
+      invokedFunctionsByFile: new Map(
+        (data.rpc.invokedFunctionsByFile || []).map(
+          ([file, fns]): [string, Set<string>] => [file, new Set(fns)]
+        )
+      ),
       usedAddons: new Set(data.rpc.usedAddons || []),
       wireAddonDeclarations: new Map(data.rpc.wireAddonDeclarations || []),
       wireAddonFiles: new Set(data.rpc.wireAddonFiles || []),

package/src/utils/workflow/dsl/patterns.ts

@@ -6,7 +6,7 @@ import * as ts from 'typescript'
 
 /**
  * Check if a call expression is workflow.do() or workflow.expectEventually()
- * (both are RPC steps; expectEventually is the polling variant used by user flows)
+ * (both are RPC steps; expectEventually is the polling variant used by scenarios)
  */
 export function isWorkflowDoCall(
   node: ts.CallExpression,

package/src/utils/workflow/graph/convert-dsl-to-graph.ts

@@ -396,11 +396,11 @@ export function convertDslToGraph(
   const entryNodeIds = nodes.length > 0 ? [nodes[0].nodeId] : []
 
   // Determine source type:
-  // - userFlow: complex workflow whose steps run as actors (user flow)
+  // - scenario: complex workflow whose steps run as actors (scenario)
   // - dsl === true: pure DSL workflow, can be serialized
   // - dsl === false: complex workflow with inline steps, not serializable
-  const source = meta.userFlow
-    ? 'user-flow'
+  const source = meta.scenario
+    ? 'scenario'
     : meta.dsl === false
       ? 'complex'
       : 'dsl'

package/src/utils/workflow/graph/workflow-graph.types.ts

@@ -142,9 +142,9 @@ export interface FunctionNode extends BaseNode {
   outputVar?: string
   /** Hash of nodeId + RPC input/output schemas for version detection */
   stepHash?: string
-  /** User-flow actor name this step runs as (workflow.do {actor: actors.x}) */
+  /** Scenario actor name this step runs as (workflow.do {actor: actors.x}) */
   actor?: string
-  /** True for workflow.expectEventually polling steps (user flows) */
+  /** True for workflow.expectEventually polling steps (scenarios) */
   expectEventually?: boolean
 }
 
@@ -181,9 +181,9 @@ export const isFlowNode = (node: SerializedGraphNode): node is FlowNode =>
  * - 'dsl': Pure DSL workflow (pikkuWorkflowFunc) - can be round-tripped to code
  * - 'complex': Complex workflow (pikkuWorkflowComplexFunc) - contains inline steps, not serializable
  * - 'graph': Graph-based workflow (pikkuWorkflowGraph)
- * - 'user-flow': User flow (pikkuUserFlow) - complex workflow whose steps run as actors
+ * - 'scenario': Scenario (pikkuScenario) - complex workflow whose steps run as actors
  */
-export type WorkflowSourceType = 'dsl' | 'complex' | 'graph' | 'user-flow'
+export type WorkflowSourceType = 'dsl' | 'complex' | 'graph' | 'scenario'
 
 /**
  * Serialized workflow graph - the canonical JSON format
@@ -201,7 +201,7 @@ export interface SerializedWorkflowGraph {
   description?: string
   /** Tags for organization */
   tags?: string[]
-  /** Actor names a user flow's steps run as */
+  /** Actor names a scenario's steps run as */
   actors?: string[]
   /** If true, workflow always executes inline without queues */
   inline?: boolean