@pikku/inspector 0.12.34 → 0.12.36

package/CHANGELOG.md

@@ -1,3 +1,59 @@
+## 0.12.36
+
+### Patch Changes
+
+- 61c9ce9: Add `actor.converse(...)` — actor agents for user journeys (#850)
+
+  An actor can now hold a dynamic, LLM-driven conversation with a target Pikku AI
+  agent in its own persona:
+
+  ```ts
+  const verdict = await actors.pm.converse({
+    agent: 'todoBot',
+    task: 'Get a todo created for the launch',
+    evaluate: 'A todo about the launch now exists',
+  })
+  // verdict: { passed, reasoning, transcript }
+  // then assert deterministically as the same actor:
+  const todos = await actors.pm.invoke('listTodos', {})
+  ```
+
+  The actor drives the target over the real transport (the agent's own
+  `agentRun` / `agentApprove` HTTP routes, signed in as the actor), plays the
+  persona from its `pikku.config.json` config, answers the agent's tool-approval
+  requests in-persona (`approvals: 'in-persona' | 'always' | 'never'`), and
+  returns its verdict on whether the task was met. Deterministic checks stay the
+  caller's job — they already hold the actor.
+
+  The conversation engine is transport-agnostic (persona LLM + injected target
+  driver); the persona's own turns run in-process via the configured
+  `aiAgentRunner` (`model` from the call or the actors-service default).
+
+  `agent` is typed against the generated agent-name union (`keyof AgentMap`), so
+  it's author-time checked and autocompleted in a typed project.
+
+- 472a349: Rename the userflow concept to scenario (#862). `pikkuUserFlow` becomes `pikkuScenario`, `pikku userflow run/list` becomes `pikku scenario run/list`, the workflow meta flag `userFlow` becomes `scenario`, actor types are now `ScenarioActor`/`ScenarioActors`/`ScenarioActorConfig` (`createHttpScenarioActors`), pikku.config.json's `userFlows` key becomes `scenarios`, the generated actors file is `pikku-scenario-actors.gen.ts` (`createScenarioActors`), the actor sign-in secret env var is `SCENARIO_ACTOR_SECRET`, and the console's User Flows view is now Scenarios.
+- Updated dependencies [61c9ce9]
+- Updated dependencies [f1f39f8]
+- Updated dependencies [c45e98d]
+- Updated dependencies [472a349]
+  - @pikku/core@0.12.52
+
+## 0.12.35
+
+### Patch Changes
+
+- 7ebea62: Tree-shake addon registrations in filtered inspector states (per-unit deploy codegen).
+  - `filterInspectorState` drops an addon's `wireAddonDeclarations`/`usedAddons` unless something kept actually references it (kept wiring targeting `namespace:*`, kept agent/MCP tool, or a body-level `rpc.invoke('namespace:*')` from a file that still contains a kept function). The generated per-unit bootstrap no longer imports unused addon package bootstraps — previously every deploy unit registered every addon's entire function surface, which pulled dev-only code (e.g. `@pikku/addon-console`'s static `node:fs` imports) into Cloudflare Worker bundles and failed upload with `No such module "node:fs"`.
+  - Body-level `rpc.invoke()` targets are now tracked per source file (`rpc.invokedFunctionsByFile`) so wiring-level `ref()` targets no longer pin an addon into every unit.
+  - `aggregateRequiredServices` computes addon parent services per used addon function (from the addon's shipped per-function `services` meta) instead of blanket-adding `addonRequiredParentServices` — and matches namespaced ids only, so bare project function names colliding with addon function names no longer force the blanket.
+  - Addon builds keep per-function `services` in the shipped `pikku-functions-meta.gen.json` so parent projects can do the above; addons built before this fall back to the blanket.
+  - HTTP route meta records `refTarget` for `ref('namespace:fn')`-wired routes, so per-unit filtering keeps the addon registration (and only that function's services) when the route deploys.
+
+- Updated dependencies [7ebea62]
+- Updated dependencies [e57dd65]
+  - @pikku/core@0.12.51
+
 ## 0.12.34
 
 ### Patch Changes

package/dist/add/add-functions.js

@@ -251,10 +251,10 @@ export const addFunctions = (logger, node, checker, state, options) => {
         return;
     }
     // Match identifiers that contain both "pikku" and "func" (case insensitive),
-    // plus pikkuUserFlow (a workflow wrapper without "func" in its name)
+    // plus pikkuScenario (a workflow wrapper without "func" in its name)
     const pikkuFuncPattern = /pikku.*func/i;
     if (!pikkuFuncPattern.test(expression.text) &&
-        expression.text !== 'pikkuUserFlow') {
+        expression.text !== 'pikkuScenario') {
         return;
     }
     // only handle calls like pikkuFunc(...)

package/dist/add/add-http-route.js

@@ -220,8 +220,10 @@ export function registerHTTPRoute({ obj, state, checker, logger, sourceFile, bas
     const middleware = resolveHTTPMiddlewareFromObject(state, fullRoute, obj, tags, checker);
     // Resolve permissions
     const permissions = resolveHTTPPermissionsFromObject(state, fullRoute, obj, tags, checker);
-    // Track used functions/middleware/permissions for service aggregation
     state.serviceAggregation.usedFunctions.add(funcName);
+    if (refAddonTarget) {
+        state.serviceAggregation.usedFunctions.add(refAddonTarget);
+    }
     extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
     extractWireNames(permissions).forEach((name) => state.serviceAggregation.usedPermissions.add(name));
     // Check for SSE
@@ -232,6 +234,7 @@ export function registerHTTPRoute({ obj, state, checker, logger, sourceFile, bas
     state.http.files.add(sourceFile.fileName);
     state.http.meta[method][fullRoute] = {
         pikkuFuncId: funcName,
+        ...(refAddonTarget && { refTarget: refAddonTarget }),
         ...(packageName && { packageName }),
         route: fullRoute,
         sourceFile: sourceFile.fileName,

package/dist/add/add-rpc-invocations.js

@@ -85,10 +85,17 @@ export function addRPCInvocations(node, state, logger) {
                     const functionRef = firstArg.text;
                     logger.debug(`• Found RPC invocation: ${functionRef}`);
                     state.rpc.invokedFunctions.add(functionRef);
+                    let byFile = state.rpc.invokedFunctionsByFile.get(sourceFileName);
+                    if (!byFile) {
+                        byFile = new Set();
+                        state.rpc.invokedFunctionsByFile.set(sourceFileName, byFile);
+                    }
+                    byFile.add(functionRef);
                     const namespace = extractNamespace(functionRef);
                     if (namespace) {
                         logger.debug(`  → Addon detected: ${namespace}`);
                         state.rpc.usedAddons.add(namespace);
+                        state.serviceAggregation.usedFunctions.add(functionRef);
                     }
                 }
                 // Handle template literals like `function-${name}`

package/dist/add/add-workflow.d.ts

@@ -6,6 +6,6 @@ import type { WorkflowStepMeta } from '@pikku/core/workflow';
 export declare function collectInvokedRPCs(steps: WorkflowStepMeta[], rpcs: Set<string>): void;
 /**
  * Inspector for pikkuWorkflowFunc(), pikkuWorkflowComplexFunc() and
- * pikkuUserFlow() calls. Detects workflow registration and extracts metadata.
+ * pikkuScenario() calls. Detects workflow registration and extracts metadata.
  */
 export declare const addWorkflow: AddWiring;

package/dist/add/add-workflow.js

@@ -19,6 +19,25 @@ function extractStepName(node, checker) {
         return getSourceText(node);
     }
 }
+/**
+ * Walk a function body for any `X.expectEventually(...)` call. Used to enforce
+ * that the durable-polling assertion is a scenario-only primitive — regular
+ * workflows must not carry test/assertion semantics.
+ */
+function containsExpectEventuallyCall(node) {
+    if (ts.isCallExpression(node) &&
+        ts.isPropertyAccessExpression(node.expression) &&
+        node.expression.name.text === 'expectEventually') {
+        return true;
+    }
+    let found = false;
+    ts.forEachChild(node, (child) => {
+        if (!found && !ts.isFunctionDeclaration(child)) {
+            found = containsExpectEventuallyCall(child);
+        }
+    });
+    return found;
+}
 /**
  * Recursively check if any step has inline type (non-serializable)
  */
@@ -177,7 +196,7 @@ function getWorkflowInvocations(node, checker, state, workflowName, steps) {
 }
 /**
  * Inspector for pikkuWorkflowFunc(), pikkuWorkflowComplexFunc() and
- * pikkuUserFlow() calls. Detects workflow registration and extracts metadata.
+ * pikkuScenario() calls. Detects workflow registration and extracts metadata.
  */
 export const addWorkflow = (logger, node, checker, state) => {
     if (!ts.isCallExpression(node)) {
@@ -196,10 +215,10 @@ export const addWorkflow = (logger, node, checker, state) => {
     else if (expression.text === 'pikkuWorkflowComplexFunc') {
         wrapperType = 'complex';
     }
-    else if (expression.text === 'pikkuUserFlow') {
-        // A user flow is a complex workflow whose steps run as actors over the
+    else if (expression.text === 'pikkuScenario') {
+        // A scenario is a complex workflow whose steps run as actors over the
         // real transport — same extraction rules as complex, distinct meta.
-        wrapperType = 'user-flow';
+        wrapperType = 'scenario';
     }
     else {
         return;
@@ -244,6 +263,15 @@ export const addWorkflow = (logger, node, checker, state) => {
         logger.critical(ErrorCode.MISSING_FUNC, `Could not resolve workflow function for '${workflowName}'.`);
         return;
     }
+    // expectEventually is a scenario-only assertion primitive — regular
+    // workflows must stay free of test/eval semantics.
+    if (wrapperType !== 'scenario' &&
+        containsExpectEventuallyCall(resolvedFunc)) {
+        logger.critical(ErrorCode.EXPECT_EVENTUALLY_SCENARIO_ONLY, `Workflow '${workflowName}' calls workflow.expectEventually(), which is only ` +
+            `available in scenarios (pikkuScenario). Move it into a scenario, or drive ` +
+            `the assertion outside the workflow.`);
+        return;
+    }
     // Track workflow file for wiring generation
     if (exportedName) {
         state.workflows.files.set(pikkuFuncId, {
@@ -308,8 +336,8 @@ export const addWorkflow = (logger, node, checker, state) => {
         const sink = steps.length > 0 ? [] : steps;
         getWorkflowInvocations(resolvedFunc, checker, state, workflowName, sink);
     }
-    // Actor names the flow's steps run as (user flows) — powers the console
-    // personas view and the User Flow graph badges.
+    // Actor names the flow's steps run as (scenarios) — powers the console
+    // personas view and the Scenario graph badges.
     const actorNames = [
         ...new Set(steps
             .map((s) => ('actor' in s ? s.actor : undefined))
@@ -327,19 +355,19 @@ export const addWorkflow = (logger, node, checker, state) => {
         errors,
         tags,
         expose,
-        userFlow: wrapperType === 'user-flow' ? true : undefined,
+        scenario: wrapperType === 'scenario' ? true : undefined,
         actors: actorNames.length > 0 ? actorNames : undefined,
     };
-    // User flows are pure stories of remote RPCs (same rule as client-side CLI
+    // Scenarios are pure stories of remote RPCs (same rule as client-side CLI
     // renderers): the func may only destructure logger/config — everything else
     // must go through actor steps so the flow runs against the TARGET
     // environment, never local services.
     const funcMeta = state.functions.meta[pikkuFuncId];
-    if (wrapperType === 'user-flow' && funcMeta?.services) {
+    if (wrapperType === 'scenario' && funcMeta?.services) {
         const disallowed = funcMeta.services.services.filter((svc) => svc !== 'logger' && svc !== 'config');
         if (disallowed.length > 0) {
-            logger.critical(ErrorCode.USER_FLOW_HAS_SERVICES, `User flow '${workflowName}' destructures services: ${disallowed.join(', ')}. ` +
-                `User flows may only use 'logger'/'config' — drive everything else through ` +
+            logger.critical(ErrorCode.SCENARIO_HAS_SERVICES, `Scenario '${workflowName}' destructures services: ${disallowed.join(', ')}. ` +
+                `Scenarios may only use 'logger'/'config' — drive everything else through ` +
                 `actor steps (workflow.do(step, rpc, data, { actor: actors.x })) so the flow ` +
                 `runs against the target environment.`);
             return;

package/dist/error-codes.d.ts

@@ -19,7 +19,8 @@ export declare enum ErrorCode {
     MISSING_QUEUE_NAME = "PKU384",
     MISSING_CHANNEL_NAME = "PKU400",
     CLI_CLIENTSIDE_RENDERER_HAS_SERVICES = "PKU672",
-    USER_FLOW_HAS_SERVICES = "PKU673",
+    SCENARIO_HAS_SERVICES = "PKU673",
+    EXPECT_EVENTUALLY_SCENARIO_ONLY = "PKU675",
     DYNAMIC_STEP_NAME = "PKU529",
     WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED = "PKU600",
     INVALID_DSL_WORKFLOW = "PKU641",

package/dist/error-codes.js

@@ -21,7 +21,8 @@ export var ErrorCode;
     ErrorCode["MISSING_QUEUE_NAME"] = "PKU384";
     ErrorCode["MISSING_CHANNEL_NAME"] = "PKU400";
     ErrorCode["CLI_CLIENTSIDE_RENDERER_HAS_SERVICES"] = "PKU672";
-    ErrorCode["USER_FLOW_HAS_SERVICES"] = "PKU673";
+    ErrorCode["SCENARIO_HAS_SERVICES"] = "PKU673";
+    ErrorCode["EXPECT_EVENTUALLY_SCENARIO_ONLY"] = "PKU675";
     ErrorCode["DYNAMIC_STEP_NAME"] = "PKU529";
     ErrorCode["WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED"] = "PKU600";
     ErrorCode["INVALID_DSL_WORKFLOW"] = "PKU641";

package/dist/inspector.js

@@ -93,6 +93,7 @@ export function getInitialInspectorState(rootDir) {
             exposedMeta: {},
             exposedFiles: new Map(),
             invokedFunctions: new Set(),
+            invokedFunctionsByFile: new Map(),
             usedAddons: new Set(),
             wireAddonDeclarations: new Map(),
             wireAddonFiles: new Set(),

package/dist/types.d.ts

@@ -413,6 +413,7 @@ export interface InspectorState {
             exportedName: string;
         }>;
         invokedFunctions: Set<string>;
+        invokedFunctionsByFile: Map<string, Set<string>>;
         usedAddons: Set<string>;
         wireAddonDeclarations: Map<string, {
             package: string;

package/dist/utils/filter-inspector-state.js

@@ -366,6 +366,9 @@ export function filterInspectorState(state, filters, logger) {
                 // Track used functions/middleware/permissions
                 if (routeMeta.pikkuFuncId) {
                     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(':');
@@ -796,6 +799,46 @@ export function filterInspectorState(state, filters, logger) {
     if (filteredState.serviceAggregation.requiredServices.has('workflowService')) {
         filteredState.serviceAggregation.requiredServices.add('queueService');
     }
+    if ((filteredState.rpc.wireAddonDeclarations?.size ?? 0) > 0) {
+        const referencedIds = new Set(filteredState.serviceAggregation.usedFunctions);
+        const keptFiles = new Set();
+        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()) {
+            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 ?? {})) {
+            if (toolMeta.pikkuFuncId)
+                referencedIds.add(toolMeta.pikkuFuncId);
+        }
+        for (const agentMeta of Object.values(filteredState.agents?.agentsMeta ?? {})) {
+            for (const tool of agentMeta.tools ?? [])
+                referencedIds.add(tool);
+        }
+        const keptNamespaces = new Set();
+        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;

package/dist/utils/load-addon-functions-meta.js

@@ -135,6 +135,7 @@ export async function loadAddonFunctionsMeta(logger, state) {
                 // 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`);
                 const addonMetaRaw = await readFile(addonMetaPath, 'utf-8');
@@ -144,24 +145,29 @@ export async function loadAddonFunctionsMeta(logger, state) {
                     state.addonServerlessIncompatible.set(namespace, addonMeta.serverlessIncompatible);
                     logger.debug(`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)) {
-                    for (const service of servicesModule.requiredParentServices) {
+                if (Array.isArray(addonMeta.requiredParentServices) &&
+                    addonMeta.requiredParentServices.length > 0) {
+                    for (const service of addonMeta.requiredParentServices) {
                         state.addonRequiredParentServices.push(service);
                     }
-                    logger.debug(`Loaded ${servicesModule.requiredParentServices.length} required parent services for '${namespace}' from ${decl.package}`);
+                    loadedParentServices = true;
+                    logger.debug(`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 {
                 const httpContractsPath = require.resolve(`${decl.package}/.pikku/http/pikku-http-contracts-meta.gen.json`);

package/dist/utils/post-process.js

@@ -253,19 +253,44 @@ export function aggregateRequiredServices(state) {
         requiredServices.add('eventHub');
     }
     // 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();
-    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();
+    for (const [namespace, fns] of Object.entries(state.addonFunctions ?? {})) {
+        for (const [id, meta] of Object.entries(fns)) {
+            addonFnServices.set(`${namespace}:${id}`, meta?.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/dist/utils/serialize-inspector-state.d.ts

@@ -178,6 +178,7 @@ export interface SerializableInspectorState {
             exportedName: string;
         }]>;
         invokedFunctions: string[];
+        invokedFunctionsByFile?: Array<[string, string[]]>;
         usedAddons: string[];
         wireAddonDeclarations: Array<[
             string,

package/dist/utils/serialize-inspector-state.js

@@ -78,6 +78,7 @@ export function serializeInspectorState(state) {
             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()).entries()).map(([file, fns]) => [file, Array.from(fns)]),
             usedAddons: Array.from(state.rpc.usedAddons),
             wireAddonDeclarations: Array.from(state.rpc.wireAddonDeclarations.entries()),
             wireAddonFiles: Array.from(state.rpc.wireAddonFiles),
@@ -235,6 +236,7 @@ export function deserializeInspectorState(data) {
             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]) => [file, new Set(fns)])),
             usedAddons: new Set(data.rpc.usedAddons || []),
             wireAddonDeclarations: new Map(data.rpc.wireAddonDeclarations || []),
             wireAddonFiles: new Set(data.rpc.wireAddonFiles || []),

package/dist/utils/workflow/dsl/patterns.d.ts

@@ -4,7 +4,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 declare function isWorkflowDoCall(node: ts.CallExpression, checker: ts.TypeChecker): boolean;
 /**

package/dist/utils/workflow/dsl/patterns.js

@@ -4,7 +4,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, checker) {
     if (!ts.isPropertyAccessExpression(node.expression)) {

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

@@ -298,11 +298,11 @@ export function convertDslToGraph(workflowName, meta) {
     }
     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/dist/utils/workflow/graph/workflow-graph.types.d.ts

@@ -96,9 +96,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;
 }
 /**
@@ -127,9 +127,9 @@ export declare 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
  */
@@ -146,7 +146,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.34",
+  "version": "0.12.36",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "type": "module",
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.1",
-    "@pikku/core": "^0.12.50",
+    "@pikku/core": "^0.12.52",
     "openapi-types": "^12.1.3",
     "path-to-regexp": "^8.3.0",
     "ts-json-schema-generator": "2.9.1-next.16",

package/run-tests.sh

@@ -38,16 +38,16 @@ if [ ${#files[@]} -eq 0 ]; then
 fi
 
 # Construct the node command
-node_cmd="node --import tsx --test"
+node_cmd=(node --import tsx --test)
 
 # Append options based on flags
 if [ "$watch_mode" = true ]; then
-  node_cmd="$node_cmd --watch"
+  node_cmd+=(--watch)
 fi
 
 if [ "$coverage_mode" = true ]; then
-  node_cmd="$node_cmd --test-coverage-include=\"src/**/*.{ts,js}\" --test-coverage-exclude=\"**/dist/**\" --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info"
+  node_cmd+=(--test-coverage-include="src/**/*.{ts,js}" --test-coverage-exclude="**/dist/**" --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info)
 fi
 
 # Execute the node command with the expanded list of files
-$node_cmd "${files[@]}"
+"${node_cmd[@]}" "${files[@]}"

package/src/add/add-functions.ts

@@ -358,11 +358,11 @@ export const addFunctions: AddWiring = (
   }
 
   // Match identifiers that contain both "pikku" and "func" (case insensitive),
-  // plus pikkuUserFlow (a workflow wrapper without "func" in its name)
+  // plus pikkuScenario (a workflow wrapper without "func" in its name)
   const pikkuFuncPattern = /pikku.*func/i
   if (
     !pikkuFuncPattern.test(expression.text) &&
-    expression.text !== 'pikkuUserFlow'
+    expression.text !== 'pikkuScenario'
   ) {
     return
   }
@@ -494,9 +494,15 @@ export const addFunctions: AddWiring = (
     approvalRequired = getPropertyValue(firstArg, 'approvalRequired') as
       | boolean
       | undefined
-    workflowQueued = getPropertyValue(firstArg, 'workflowQueued') as boolean | undefined
-    workflowRetries = getPropertyValue(firstArg, 'workflowRetries') as number | undefined
-    workflowTimeout = getPropertyValue(firstArg, 'workflowTimeout') as string | undefined
+    workflowQueued = getPropertyValue(firstArg, 'workflowQueued') as
+      | boolean
+      | undefined
+    workflowRetries = getPropertyValue(firstArg, 'workflowRetries') as
+      | number
+      | undefined
+    workflowTimeout = getPropertyValue(firstArg, 'workflowTimeout') as
+      | string
+      | undefined
 
     // Extract approvalDescription identifier reference
     for (const prop of firstArg.properties) {

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

@@ -389,8 +389,10 @@ export function registerHTTPRoute({
     checker
   )
 
-  // Track used functions/middleware/permissions for service aggregation
   state.serviceAggregation.usedFunctions.add(funcName)
+  if (refAddonTarget) {
+    state.serviceAggregation.usedFunctions.add(refAddonTarget)
+  }
   extractWireNames(middleware).forEach((name) =>
     state.serviceAggregation.usedMiddleware.add(name)
   )
@@ -415,6 +417,7 @@ export function registerHTTPRoute({
   state.http.files.add(sourceFile.fileName)
   state.http.meta[method][fullRoute] = {
     pikkuFuncId: funcName,
+    ...(refAddonTarget && { refTarget: refAddonTarget }),
     ...(packageName && { packageName }),
     route: fullRoute,
     sourceFile: sourceFile.fileName,