@pikku/inspector 0.12.6 → 0.12.8

package/dist/utils/post-process.js

@@ -160,6 +160,69 @@ export function aggregateRequiredServices(state) {
             }
         });
     }
+    // 6. Implicit platform services required by wiring types
+    // Workflows need workflowService + workflowRunService + schedulerService + queueService.
+    // Check workflow definitions, graph meta, AND helper functions (workflowStart:*, etc.)
+    // that wrap workflow operations but don't destructure the services.
+    const hasWorkflows = Object.keys(state.workflows.graphMeta).length > 0 ||
+        Object.keys(state.workflows.meta).length > 0 ||
+        Object.keys(state.functions.meta).some((id) => id.startsWith('workflowStart:') ||
+            id.startsWith('workflowStatus:') ||
+            id.startsWith('workflow:'));
+    if (hasWorkflows) {
+        requiredServices.add('workflowService');
+        requiredServices.add('workflowRunService');
+        requiredServices.add('schedulerService');
+        requiredServices.add('queueService');
+    }
+    // 6b. Inject synthetic queue workers for workflow graph steps.
+    // Each workflow gets an orchestrator queue and per-step queues.
+    // Without these, the PikkuWorkflowService constructor can't find
+    // per-workflow queue entries and falls back to shared queue names.
+    for (const [, graph] of Object.entries(state.workflows.graphMeta)) {
+        if (!graph.nodes || !graph.name)
+            continue;
+        const toKebab = (s) => s
+            .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+            .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+            .toLowerCase();
+        // Orchestrator queue
+        const orchQueueName = `wf-orchestrator-${toKebab(graph.name)}`;
+        if (!state.queueWorkers.meta[orchQueueName]) {
+            state.queueWorkers.meta[orchQueueName] = {
+                name: orchQueueName,
+                pikkuFuncId: `pikkuWorkflowOrchestrator:${graph.name}`,
+            };
+        }
+        // Per-step queues
+        for (const node of Object.values(graph.nodes)) {
+            if (!('rpcName' in node) || !node.rpcName)
+                continue;
+            const rpcName = node.rpcName;
+            const stepQueueName = `wf-step-${toKebab(rpcName)}`;
+            if (!state.queueWorkers.meta[stepQueueName]) {
+                state.queueWorkers.meta[stepQueueName] = {
+                    name: stepQueueName,
+                    pikkuFuncId: `pikkuWorkflowWorker:${rpcName}`,
+                };
+            }
+        }
+    }
+    // AI agents need aiStorage + aiRunState + agentRunService + aiAgentRunner
+    if (Object.keys(state.agents.agentsMeta).length > 0) {
+        requiredServices.add('aiStorage');
+        requiredServices.add('aiRunState');
+        requiredServices.add('agentRunService');
+        requiredServices.add('aiAgentRunner');
+    }
+    // Channels need eventHub for pub/sub
+    if (Object.keys(state.channels.meta).length > 0) {
+        requiredServices.add('eventHub');
+    }
+    // 7. Services that addons need from the parent project
+    for (const service of state.addonRequiredParentServices ?? []) {
+        requiredServices.add(service);
+    }
 }
 export function validateSecretOverrides(logger, state) {
     const { wireAddonDeclarations } = state.rpc;

package/dist/utils/schema-generator.js

@@ -1,7 +1,7 @@
 import * as ts from 'typescript';
 import { dirname, join, resolve } from 'path';
 import { createGenerator, RootlessError } from 'ts-json-schema-generator';
-import { tsImport } from 'tsx/esm/api';
+import { register, tsImport } from 'tsx/esm/api';
 import * as z from 'zod';
 import { zodToTs, createAuxiliaryTypeStore } from 'zod-to-ts';
 import { ErrorCode } from '../error-codes.js';
@@ -44,6 +44,9 @@ function primitiveTypeToSchema(typeStr) {
     if (normalized === 'null') {
         return { type: 'null' };
     }
+    if (normalized === 'any' || normalized === 'unknown') {
+        return {};
+    }
     return null;
 }
 // Cached state for schema program reuse across inspect() calls
@@ -89,7 +92,7 @@ function createProgramWithVirtualFile(tsconfig, virtualFilePath, virtualFileCont
     cachedSchemaProgram = program;
     return program;
 }
-function generateTSSchemas(logger, tsconfig, customTypesContent, typesMap, functionMeta, httpWiringsMeta, additionalTypes, additionalProperties = false, schemaLookup) {
+function generateTSSchemas(logger, tsconfig, customTypesContent, typesMap, functionMeta, httpWiringsMeta, additionalTypes, additionalProperties = false, generatedZodSchemas) {
     const schemasSet = new Set(typesMap.customTypes.keys());
     for (const { inputs, outputs } of Object.values(functionMeta)) {
         const types = [...(inputs || []), ...(outputs || [])];
@@ -123,6 +126,14 @@ function generateTSSchemas(logger, tsconfig, customTypesContent, typesMap, funct
             schemasSet.add(type);
         }
     }
+    // Skip ts-json-schema-generator if all schemas are already covered by Zod/primitives.
+    // Use generatedZodSchemas (actually converted) rather than schemaLookup (all attempted)
+    // so that failed Zod conversions fall through to TS schema generation.
+    const uncoveredSchemas = [...schemasSet].filter((s) => !PRIMITIVE_TYPES.has(s) && !generatedZodSchemas?.[s]);
+    if (uncoveredSchemas.length === 0) {
+        return {};
+    }
+    logger.debug(`generateTSSchemas needed for ${uncoveredSchemas.length} types: ${uncoveredSchemas.slice(0, 3).join(', ')}${uncoveredSchemas.length > 3 ? '...' : ''}`);
     const virtualFilePath = join(dirname(resolve(tsconfig)), '__pikku_virtual_types__.ts');
     const program = createProgramWithVirtualFile(tsconfig, virtualFilePath, customTypesContent);
     const generator = createGenerator({
@@ -142,7 +153,7 @@ function generateTSSchemas(logger, tsconfig, customTypesContent, typesMap, funct
         if (PRIMITIVE_TYPES.has(schema)) {
             return;
         }
-        if (schemaLookup?.has(schema)) {
+        if (generatedZodSchemas?.[schema]) {
             return;
         }
         try {
@@ -165,53 +176,133 @@ function generateTSSchemas(logger, tsconfig, customTypesContent, typesMap, funct
     });
     return schemas;
 }
+/**
+ * Import all source files in parallel using tsx's register() API.
+ *
+ * tsx's register() sets up the TypeScript loader once, then all subsequent
+ * import() calls reuse that loader. This is dramatically faster than calling
+ * tsImport() per-file because tsImport() sets up and tears down a fresh
+ * compilation context for each call (~170ms each).
+ *
+ * With register() + parallel import():
+ *   - 71 files: ~350ms total
+ *   - vs tsImport loop: ~12,000ms (71 * 170ms)
+ *
+ * Falls back to serial tsImport() per-file if register() is unavailable.
+ */
+async function batchImportWithRegister(logger, sourceFiles) {
+    if (sourceFiles.length === 0)
+        return new Map();
+    let unregister;
+    try {
+        unregister = register();
+        const modules = new Map();
+        const results = await Promise.allSettled(sourceFiles.map(async (srcPath) => {
+            const mod = await import(srcPath);
+            modules.set(srcPath, mod);
+        }));
+        const failures = results.filter((r) => r.status === 'rejected');
+        if (failures.length > 0) {
+            logger.debug(`${failures.length}/${sourceFiles.length} files failed to import via register()`);
+        }
+        return modules;
+    }
+    catch (e) {
+        logger.debug(`tsx register() batch import failed: ${e.message}`);
+        return null;
+    }
+    finally {
+        unregister?.();
+    }
+}
+function processZodSchema(schemaName, zodSchema, schemas, typesMap, auxiliaryTypeStore, printer, fakeSourceFile, logger) {
+    const schema = z.toJSONSchema(zodSchema, {
+        unrepresentable: 'any',
+        override: ({ zodSchema, jsonSchema }) => {
+            if (zodSchema._zod?.def?.type === 'date') {
+                ;
+                jsonSchema.type = 'string';
+                jsonSchema.format = 'date-time';
+            }
+        },
+    });
+    if (schema.required && schema.properties) {
+        schema.required = schema.required.filter((fieldName) => {
+            const prop = schema.properties[fieldName];
+            return prop && prop.default === undefined;
+        });
+        if (schema.required.length === 0) {
+            delete schema.required;
+        }
+    }
+    const { node: tsType } = zodToTs(zodSchema, { auxiliaryTypeStore });
+    const typeText = printer.printNode(ts.EmitHint.Unspecified, tsType, fakeSourceFile);
+    typesMap.addCustomType(schemaName, typeText, []);
+    schemas[schemaName] = schema;
+    logger.debug(`• Generated schema from Zod: ${schemaName}`);
+}
 async function generateZodSchemas(logger, schemaLookup, typesMap) {
     const schemas = {};
     const auxiliaryTypeStore = createAuxiliaryTypeStore();
     const printer = ts.createPrinter();
     const fakeSourceFile = ts.createSourceFile('zod-types.ts', '', ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
+    // Validate all schemas are zod (or unspecified vendor)
     for (const [schemaName, ref] of schemaLookup.entries()) {
         if (ref.vendor && ref.vendor !== 'zod') {
             throw new Error(`Schema '${schemaName}' uses ${ref.vendor} which is not yet supported for JSON Schema generation. ` +
                 `Currently only Zod schemas can be converted to JSON Schema. ` +
                 `Please use Zod or contribute support for ${ref.vendor}.`);
         }
-        try {
-            const module = await tsImport(ref.sourceFile, import.meta.url);
-            const zodSchema = module[ref.variableName];
+    }
+    // Collect unique source files and batch-import them in parallel
+    const uniqueSourceFiles = [
+        ...new Set([...schemaLookup.values()].map((ref) => ref.sourceFile)),
+    ];
+    console.log(`[TIMING] Zod schemas: ${schemaLookup.size} schemas from ${uniqueSourceFiles.length} files`);
+    const importStart = performance.now();
+    const importedModules = await batchImportWithRegister(logger, uniqueSourceFiles);
+    console.log(`[TIMING] Batch import: ${(performance.now() - importStart).toFixed(0)}ms`);
+    const processStart = performance.now();
+    // Track schemas that need per-file tsImport fallback
+    const fallbackSchemas = [];
+    for (const [schemaName, ref] of schemaLookup.entries()) {
+        const mod = importedModules?.get(ref.sourceFile);
+        if (mod) {
+            const zodSchema = mod[ref.variableName];
             if (!zodSchema) {
-                logger.warn(`Could not find exported schema '${ref.variableName}' in ${ref.sourceFile} for ${schemaName}. Available exports: ${Object.keys(module).join(', ')}`);
+                logger.warn(`Could not find exported schema '${ref.variableName}' in ${ref.sourceFile} for ${schemaName}. Available exports: ${Object.keys(mod).join(', ')}`);
                 continue;
             }
-            const schema = z.toJSONSchema(zodSchema, {
-                unrepresentable: 'any',
-                override: ({ zodSchema, jsonSchema }) => {
-                    if (zodSchema._zod?.def?.type === 'date') {
-                        ;
-                        jsonSchema.type = 'string';
-                        jsonSchema.format = 'date-time';
-                    }
-                },
-            });
-            if (schema.required && schema.properties) {
-                schema.required = schema.required.filter((fieldName) => {
-                    const prop = schema.properties[fieldName];
-                    return prop && prop.default === undefined;
-                });
-                if (schema.required.length === 0) {
-                    delete schema.required;
-                }
+            try {
+                processZodSchema(schemaName, zodSchema, schemas, typesMap, auxiliaryTypeStore, printer, fakeSourceFile, logger);
+            }
+            catch (e) {
+                logger.warn(`Could not convert Zod schema '${schemaName}': ${e instanceof Error ? e.message : e}`);
             }
-            schemas[schemaName] = schema;
-            const { node: tsType } = zodToTs(zodSchema, { auxiliaryTypeStore });
-            const typeText = printer.printNode(ts.EmitHint.Unspecified, tsType, fakeSourceFile);
-            typesMap.addCustomType(schemaName, typeText, []);
-            logger.debug(`• Generated schema from Zod: ${schemaName}`);
         }
-        catch (e) {
-            logger.warn(`Could not convert Zod schema '${schemaName}': ${e instanceof Error ? e.message : e}`);
+        else {
+            fallbackSchemas.push([schemaName, ref]);
+        }
+    }
+    // Fallback: use tsImport for any schemas that batch import couldn't handle
+    if (fallbackSchemas.length > 0) {
+        logger.debug(`Falling back to tsImport for ${fallbackSchemas.length} schema(s)`);
+        for (const [schemaName, ref] of fallbackSchemas) {
+            try {
+                const module = await tsImport(ref.sourceFile, import.meta.url);
+                const zodSchema = module[ref.variableName];
+                if (!zodSchema) {
+                    logger.warn(`Could not find exported schema '${ref.variableName}' in ${ref.sourceFile} for ${schemaName}. Available exports: ${Object.keys(module).join(', ')}`);
+                    continue;
+                }
+                processZodSchema(schemaName, zodSchema, schemas, typesMap, auxiliaryTypeStore, printer, fakeSourceFile, logger);
+            }
+            catch (e) {
+                logger.warn(`Could not convert Zod schema '${schemaName}': ${e instanceof Error ? e.message : e}`);
+            }
         }
     }
+    console.log(`[TIMING] Process schemas: ${(performance.now() - processStart).toFixed(0)}ms (${Object.keys(schemas).length} generated)`);
     return schemas;
 }
 export async function generateAllSchemas(logger, config, state) {
@@ -222,7 +313,7 @@ export async function generateAllSchemas(logger, config, state) {
         logger.debug('Reusing cached TS schemas (types unchanged)');
         return { ...cachedTSSchemas, ...zodSchemas };
     }
-    const tsSchemas = generateTSSchemas(logger, config.tsconfig, customTypesContent, state.functions.typesMap, state.functions.meta, state.http.meta, config.schemasFromTypes, config.schema?.additionalProperties, state.schemaLookup);
+    const tsSchemas = generateTSSchemas(logger, config.tsconfig, customTypesContent, state.functions.typesMap, state.functions.meta, state.http.meta, config.schemasFromTypes, config.schema?.additionalProperties, zodSchemas);
     cachedCustomTypesContent = customTypesContent;
     cachedTSSchemas = tsSchemas;
     return { ...tsSchemas, ...zodSchemas };

package/dist/utils/serialize-inspector-state.d.ts

@@ -55,6 +55,7 @@ export interface SerializableInspectorState {
         }[]
     ]>;
     wireServicesMeta: Array<[string, string[]]>;
+    addonRequiredParentServices: string[];
     configFactories: Array<[
         string,
         {

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

@@ -23,6 +23,7 @@ export function serializeInspectorState(state) {
         singletonServicesFactories: Array.from(state.singletonServicesFactories.entries()),
         wireServicesFactories: Array.from(state.wireServicesFactories.entries()),
         wireServicesMeta: Array.from(state.wireServicesMeta.entries()),
+        addonRequiredParentServices: state.addonRequiredParentServices,
         configFactories: Array.from(state.configFactories.entries()),
         filesAndMethods: state.filesAndMethods,
         filesAndMethodsErrors: Array.from(state.filesAndMethodsErrors.entries()).map(([key, mapValue]) => [key, Array.from(mapValue.entries())]),
@@ -167,6 +168,7 @@ export function deserializeInspectorState(data) {
         singletonServicesFactories: new Map(data.singletonServicesFactories),
         wireServicesFactories: new Map(data.wireServicesFactories),
         wireServicesMeta: new Map(data.wireServicesMeta),
+        addonRequiredParentServices: data.addonRequiredParentServices || [],
         configFactories: new Map(data.configFactories),
         filesAndMethods: data.filesAndMethods,
         filesAndMethodsErrors: new Map(data.filesAndMethodsErrors.map(([key, entries]) => [

package/dist/visit.js

@@ -28,7 +28,7 @@ export const visitSetup = (logger, checker, node, state, options) => {
     addFileExtendsCoreType(node, checker, state.wireServicesTypeImportMap, 'CoreServices', state);
     addFileExtendsCoreType(node, checker, state.userSessionTypeImportMap, 'CoreUserSession', state);
     addFileExtendsCoreType(node, checker, state.configTypeImportMap, 'CoreConfig', state);
-    addFileWithFactory(node, checker, state.singletonServicesFactories, 'CreateSingletonServices');
+    addFileWithFactory(node, checker, state.singletonServicesFactories, 'CreateSingletonServices', state);
     addFileWithFactory(node, checker, state.wireServicesFactories, 'CreateWireServices', state);
     addFileWithFactory(node, checker, state.configFactories, 'CreateConfig');
     addRPCInvocations(node, state, logger);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.6",
+  "version": "0.12.8",
   "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.12",
+    "@pikku/core": "^0.12.15",
     "path-to-regexp": "^8.3.0",
     "ts-json-schema-generator": "^2.5.0",
     "tsx": "^4.21.0",

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

@@ -63,7 +63,7 @@ function resolveToolReferences(
         }
       }
 
-      if (calleeName === 'addon') {
+      if (calleeName === 'ref') {
         const [firstArg] = element.arguments
         if (firstArg && ts.isStringLiteral(firstArg)) {
           resolved.push(firstArg.text)
@@ -258,19 +258,17 @@ export const addAIAgent: AddWiring = (
 
     const modelValue = getPropertyValue(obj, 'model') as string | null
 
-    const instructionsValue = getPropertyValue(obj, 'instructions') as
+    const roleValue = getPropertyValue(obj, 'role') as string | null
+    const personalityValue = getPropertyValue(obj, 'personality') as
       | string
-      | string[]
       | null
+    const goalValue = getPropertyValue(obj, 'goal') as string | null
 
     const maxStepsValue = getPropertyValue(obj, 'maxSteps') as number | null
     const temperatureValue = getPropertyValue(obj, 'temperature') as
       | number
       | null
     const toolChoiceValue = getPropertyValue(obj, 'toolChoice') as string | null
-    const dynamicWorkflowsValue = getPropertyValue(obj, 'dynamicWorkflows') as
-      | string
-      | null
     const toolsValue = resolveToolReferences(
       obj,
       checker,
@@ -447,10 +445,14 @@ export const addAIAgent: AddWiring = (
     state.agents.agentsMeta[agentKey] = {
       name: nameValue,
       description,
-      instructions: instructionsValue || '',
+      role: roleValue || undefined,
+      personality: personalityValue || undefined,
+      goal: goalValue || '',
       model: modelValue || '',
       summary,
       errors,
+      sourceFile: node.getSourceFile().fileName,
+      exportedName: exportedName || undefined,
       ...(maxStepsValue !== null && { maxSteps: maxStepsValue }),
       ...(temperatureValue !== null && { temperature: temperatureValue }),
       ...(toolChoiceValue !== null && {
@@ -458,9 +460,6 @@ export const addAIAgent: AddWiring = (
       }),
       ...(toolsValue !== null && { tools: toolsValue }),
       ...(agentsValue !== null && { agents: agentsValue }),
-      ...(dynamicWorkflowsValue !== null && {
-        dynamicWorkflows: dynamicWorkflowsValue as 'read' | 'always' | 'ask',
-      }),
       tags,
       inputSchema,
       outputSchema,
@@ -470,5 +469,21 @@ export const addAIAgent: AddWiring = (
       aiMiddleware,
       permissions,
     }
+
+    // AI agent functions require platform services that aren't visible
+    // through parameter destructuring
+    const funcMeta = state.functions.meta[agentKey]
+    if (funcMeta?.services) {
+      for (const svc of [
+        'aiStorage',
+        'aiRunState',
+        'agentRunService',
+        'aiAgentRunner',
+      ]) {
+        if (!funcMeta.services.services.includes(svc)) {
+          funcMeta.services.services.push(svc)
+        }
+      }
+    }
   }
 }

package/src/add/add-channel.ts

@@ -94,8 +94,8 @@ function getHandlerNameFromExpression(
 
   // Handle call expressions
   if (ts.isCallExpression(expr)) {
-    // Handle addon('namespace:funcName') calls
-    if (ts.isIdentifier(expr.expression) && expr.expression.text === 'addon') {
+    // Handle ref('name') calls
+    if (ts.isIdentifier(expr.expression) && expr.expression.text === 'ref') {
       const [firstArg] = expr.arguments
       if (firstArg && ts.isStringLiteral(firstArg)) {
         return firstArg.text

package/src/add/add-cli.ts

@@ -349,29 +349,30 @@ function processCommand(
       if (
         ts.isCallExpression(prop.initializer) &&
         ts.isIdentifier(prop.initializer.expression) &&
-        prop.initializer.expression.text === 'addon'
+        prop.initializer.expression.text === 'ref'
       ) {
         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"`
-          )
+          throw new Error(`ref() call requires a string literal argument`)
         }
         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`
-          )
+        const addonNamespace = pikkuFuncId.includes(':')
+          ? pikkuFuncId.split(':')[0]
+          : null
+        if (addonNamespace) {
+          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
+        if (addonNamespace) {
+          meta.packageName =
+            inspectorState.rpc.wireAddonDeclarations.get(
+              addonNamespace
+            )!.package
+        }
       } else {
         pikkuFuncId = extractFunctionName(
           prop.initializer,

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

@@ -57,12 +57,7 @@ export const addFileWithFactory = (
           })
           methods.set(fileName, variables)
 
-          // Extract singleton services for CreateWireServices factories
-          if (
-            expectedTypeName === 'CreateWireServices' &&
-            state &&
-            callExpression.arguments.length > 0
-          ) {
+          if (state && callExpression.arguments.length > 0) {
             const firstArg = callExpression.arguments[0]
             let functionNode:
               | ts.ArrowFunction
@@ -75,10 +70,34 @@ export const addFileWithFactory = (
               functionNode = firstArg
             }
 
-            if (functionNode) {
+            // Extract singleton services for CreateWireServices factories
+            if (expectedTypeName === 'CreateWireServices' && functionNode) {
               const servicesMeta = extractServicesFromFunction(functionNode)
               state.wireServicesMeta.set(variableName, servicesMeta.services)
             }
+
+            // Extract existing services an addon needs from the parent
+            // (second parameter of pikkuAddonServices callback)
+            if (
+              wrapperFunctionName === 'pikkuAddonServices' &&
+              functionNode &&
+              functionNode.parameters.length >= 2
+            ) {
+              const secondParam = functionNode.parameters[1]
+              if (secondParam && ts.isObjectBindingPattern(secondParam.name)) {
+                for (const elem of secondParam.name.elements) {
+                  const name =
+                    elem.propertyName && ts.isIdentifier(elem.propertyName)
+                      ? elem.propertyName.text
+                      : ts.isIdentifier(elem.name)
+                        ? elem.name.text
+                        : undefined
+                  if (name) {
+                    state.addonRequiredParentServices.push(name)
+                  }
+                }
+              }
+            }
           }
 
           return // Early return since we found a match

package/src/add/add-functions.ts

@@ -794,6 +794,8 @@ export const addFunctions: AddWiring = (
     middleware,
     permissions,
     isDirectFunction,
+    sourceFile: node.getSourceFile().fileName,
+    exportedName: exportedName || undefined,
   }
 
   // Populate node metadata if node config is present

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

@@ -205,7 +205,11 @@ export function registerHTTPRoute({
   }
 
   const packageName = ts.isIdentifier(funcInitializer)
-    ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+    ? resolveAddonName(
+        funcInitializer,
+        checker,
+        state.rpc.wireAddonDeclarations
+      )
     : null
 
   ensureFunctionMetadata(
@@ -327,6 +331,7 @@ export function registerHTTPRoute({
     pikkuFuncId: funcName,
     ...(packageName && { packageName }),
     route: fullRoute,
+    sourceFile: sourceFile.fileName,
     method: method as HTTPMethod,
     params: params.length > 0 ? params : undefined,
     query: query.length > 0 ? query : undefined,

package/src/add/add-queue-worker.ts

@@ -67,7 +67,11 @@ export const addQueueWorker: AddWiring = (logger, node, checker, state) => {
     }
 
     const packageName = ts.isIdentifier(funcInitializer)
-      ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+      ? resolveAddonName(
+          funcInitializer,
+          checker,
+          state.rpc.wireAddonDeclarations
+        )
       : null
 
     if (!name) {

package/src/add/add-rpc-invocations.ts

@@ -27,8 +27,8 @@ export function addRPCInvocations(
   if (ts.isCallExpression(node)) {
     const { expression, arguments: args } = node
 
-    // Check for addon('namespace:function') calls
-    if (ts.isIdentifier(expression) && expression.text === 'addon') {
+    // Check for ref('name') calls
+    if (ts.isIdentifier(expression) && expression.text === 'ref') {
       const [firstArg] = args
       if (firstArg && ts.isStringLiteral(firstArg)) {
         const functionRef = firstArg.text

package/src/add/add-workflow.ts

@@ -46,7 +46,7 @@ function hasInlineSteps(steps: WorkflowStepMeta[]): boolean {
 /**
  * Recursively collect all RPC names from workflow steps
  */
-function collectInvokedRPCs(
+export function collectInvokedRPCs(
   steps: WorkflowStepMeta[],
   rpcs: Set<string>
 ): void {
@@ -210,6 +210,7 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
   let description: string | undefined
   let errors: string[] | undefined
   let inline: boolean | undefined
+  let expose: boolean | undefined
 
   if (ts.isObjectLiteralExpression(firstArg)) {
     const metadata = getCommonWireMetaData(
@@ -228,6 +229,8 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
     if (inlineProp === true) {
       inline = true
     }
+
+    expose = getPropertyValue(firstArg, 'expose') as boolean | undefined
   }
 
   // Validate that we got a valid function
@@ -334,5 +337,22 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
     errors,
     tags,
     inline,
+    expose,
+  }
+
+  // Workflow functions require platform services that aren't visible
+  // through parameter destructuring (they're accessed via workflow.do/sleep)
+  const funcMeta = state.functions.meta[pikkuFuncId]
+  if (funcMeta?.services) {
+    for (const svc of [
+      'workflowService',
+      'workflowRunService',
+      'schedulerService',
+      'queueService',
+    ]) {
+      if (!funcMeta.services.services.includes(svc)) {
+        funcMeta.services.services.push(svc)
+      }
+    }
   }
 }

package/src/inspector.ts

@@ -59,6 +59,7 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
     singletonServicesFactories: new Map(),
     wireServicesFactories: new Map(),
     wireServicesMeta: new Map(),
+    addonRequiredParentServices: [],
     configFactories: new Map(),
     filesAndMethods: {},
     filesAndMethodsErrors: new Map(),

package/src/types.ts

@@ -306,6 +306,7 @@ export interface InspectorState {
   singletonServicesFactories: PathToNameAndType
   wireServicesFactories: PathToNameAndType
   wireServicesMeta: Map<string, string[]> // variable name -> singleton services consumed
+  addonRequiredParentServices: string[] // services an addon needs from the parent (extracted from pikkuAddonServices 2nd param)
   configFactories: PathToNameAndType
   filesAndMethods: InspectorFilesAndMethods
   filesAndMethodsErrors: Map<string, PathToNameAndType>