@pikku/inspector 0.12.7 → 0.12.9

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 ## 0.12.0
 
+## 0.12.9
+
+### Patch Changes
+
+- 2ac6468: Fix workflow inspector crash when workflow.do() data object has a 'description' property
+- fbcf5b9: Add version awareness to RPC handler: versioned functions now appear in the exposed RPC type map (e.g. `getData@v1`, `getData@v2`), enabling type-safe `rpc.invoke('getData@v1', data)` calls. Tree-shaking respects specific version filters without pulling in all versions. HTTP wirings correctly resolve versioned function IDs.
+- Updated dependencies [fbcf5b9]
+  - @pikku/core@0.12.16
+
+## 0.12.8
+
+### Patch Changes
+
+- 624097e: Add deploy pipeline with provider-agnostic architecture
+
+  - Add MetaService with explicit typed API, absorb WiringService reads
+  - Add deployment service, traceId propagation, scoped logger
+  - Rewrite analyzer: one function = one worker, gateways dispatch via RPC
+  - Add Cloudflare deploy provider with plan/apply commands
+  - Add per-unit filtered codegen for deploy pipeline
+  - Skip missing metadata in wiring registration for deploy units
+  - Fix schema coercion crash when schema has no properties
+  - Fix E2E codegen: double-pass resolves cross-package Zod type imports
+
+- Updated dependencies [9e8605f]
+- Updated dependencies [624097e]
+- Updated dependencies [7ab3243]
+  - @pikku/core@0.12.15
+
 ## 0.12.7
 
 ### Patch Changes

package/dist/add/add-ai-agent.js

@@ -33,7 +33,7 @@ function resolveToolReferences(obj, checker, agentName, logger) {
                     continue;
                 }
             }
-            if (calleeName === 'addon') {
+            if (calleeName === 'ref') {
                 const [firstArg] = element.arguments;
                 if (firstArg && ts.isStringLiteral(firstArg)) {
                     resolved.push(firstArg.text);
@@ -163,11 +163,12 @@ export const addAIAgent = (logger, node, checker, state, options) => {
         if (disabled)
             return;
         const modelValue = getPropertyValue(obj, 'model');
-        const instructionsValue = getPropertyValue(obj, 'instructions');
+        const roleValue = getPropertyValue(obj, 'role');
+        const personalityValue = getPropertyValue(obj, 'personality');
+        const goalValue = getPropertyValue(obj, 'goal');
         const maxStepsValue = getPropertyValue(obj, 'maxSteps');
         const temperatureValue = getPropertyValue(obj, 'temperature');
         const toolChoiceValue = getPropertyValue(obj, 'toolChoice');
-        const dynamicWorkflowsValue = getPropertyValue(obj, 'dynamicWorkflows');
         const toolsValue = resolveToolReferences(obj, checker, nameValue || '', logger);
         if (toolsValue) {
             for (const toolName of toolsValue) {
@@ -291,10 +292,14 @@ export const addAIAgent = (logger, node, checker, state, options) => {
         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 && {
@@ -302,9 +307,6 @@ export const addAIAgent = (logger, node, checker, state, options) => {
             }),
             ...(toolsValue !== null && { tools: toolsValue }),
             ...(agentsValue !== null && { agents: agentsValue }),
-            ...(dynamicWorkflowsValue !== null && {
-                dynamicWorkflows: dynamicWorkflowsValue,
-            }),
             tags,
             inputSchema,
             outputSchema,
@@ -314,5 +316,20 @@ export const addAIAgent = (logger, node, checker, state, options) => {
             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/dist/add/add-channel.js

@@ -65,8 +65,8 @@ function getHandlerNameFromExpression(expr, checker, rootDir) {
     }
     // 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/dist/add/add-cli.js

@@ -206,22 +206,25 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
         if (propName === 'func') {
             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, typeChecker, inspectorState.rootDir).pikkuFuncId;

package/dist/add/add-file-with-factory.js

@@ -40,10 +40,7 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                         typePath: typeDeclarationPath,
                     });
                     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;
                         if (ts.isArrowFunction(firstArg)) {
@@ -52,10 +49,30 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                         else if (ts.isFunctionExpression(firstArg)) {
                             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/dist/add/add-functions.js

@@ -594,6 +594,8 @@ export const addFunctions = (logger, node, checker, state, options) => {
         middleware,
         permissions,
         isDirectFunction,
+        sourceFile: node.getSourceFile().fileName,
+        exportedName: exportedName || undefined,
     };
     // Populate node metadata if node config is present
     if (nodeDisplayName && nodeCategory && nodeType) {
@@ -613,15 +615,14 @@ export const addFunctions = (logger, node, checker, state, options) => {
     }
     if (mcpEnabled) {
         if (!description) {
-            logger.critical(ErrorCode.MISSING_DESCRIPTION, `MCP tool '${name}' is missing a description.`);
-            return;
+            logger.warn(`MCP tool '${name}' is missing a description.`);
         }
         state.mcpEndpoints.files.add(node.getSourceFile().fileName);
         state.mcpEndpoints.toolsMeta[name] = {
             pikkuFuncId,
             name,
             title: title || undefined,
-            description,
+            description: description || undefined,
             summary,
             errors,
             tags,

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

@@ -174,6 +174,7 @@ export function registerHTTPRoute({ obj, state, checker, logger, sourceFile, bas
         pikkuFuncId: funcName,
         ...(packageName && { packageName }),
         route: fullRoute,
+        sourceFile: sourceFile.fileName,
         method: method,
         params: params.length > 0 ? params : undefined,
         query: query.length > 0 ? query : undefined,

package/dist/add/add-mcp-prompt.js

@@ -58,6 +58,10 @@ export const addMCPPrompt = (logger, node, checker, state, options) => {
         }
         const inputSchema = fnMeta.inputs?.[0] || null;
         const outputSchema = fnMeta.outputs?.[0] || null;
+        if (!fnMeta.outputSchemaName) {
+            fnMeta.outputSchemaName = 'MCPPromptResponse';
+            fnMeta.outputs = ['MCPPromptResponse'];
+        }
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
         // --- resolve permissions ---

package/dist/add/add-mcp-resource.js

@@ -67,6 +67,10 @@ export const addMCPResource = (logger, node, checker, state, options) => {
         }
         const inputSchema = fnMeta.inputs?.[0] || null;
         const outputSchema = fnMeta.outputs?.[0] || null;
+        if (!fnMeta.outputSchemaName) {
+            fnMeta.outputSchemaName = 'MCPResourceResponse';
+            fnMeta.outputs = ['MCPResourceResponse'];
+        }
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
         // --- resolve permissions ---

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

@@ -19,8 +19,8 @@ export function addRPCInvocations(node, state, logger) {
     // Look for call expressions: addon('ext:hello') or rpc.invoke('...')
     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/dist/add/add-workflow.d.ts

@@ -1,4 +1,9 @@
 import type { AddWiring } from '../types.js';
+import type { WorkflowStepMeta } from '@pikku/core/workflow';
+/**
+ * Recursively collect all RPC names from workflow steps
+ */
+export declare function collectInvokedRPCs(steps: WorkflowStepMeta[], rpcs: Set<string>): void;
 /**
  * Inspector for pikkuWorkflow() and pikkuSimpleWorkflow() calls
  * Detects workflow registration and extracts metadata

package/dist/add/add-workflow.js

@@ -43,7 +43,7 @@ function hasInlineSteps(steps) {
 /**
  * Recursively collect all RPC names from workflow steps
  */
-function collectInvokedRPCs(steps, rpcs) {
+export function collectInvokedRPCs(steps, rpcs) {
     for (const step of steps) {
         if (step.type === 'rpc' && step.rpcName) {
             rpcs.add(step.rpcName);
@@ -88,7 +88,7 @@ function getWorkflowInvocations(node, checker, state, workflowName, steps) {
                     // workflow.do(stepName, rpcName|fn, data?, options?)
                     const stepNameArg = args[0];
                     const secondArg = args[1];
-                    const optionsArg = args.length >= 3 ? args[args.length - 1] : undefined;
+                    const optionsArg = args.length >= 4 ? args[args.length - 1] : undefined;
                     const stepName = extractStringLiteral(stepNameArg, checker);
                     const description = extractDescription(optionsArg, checker) ?? undefined;
                     // Determine form by checking 2nd argument type
@@ -183,6 +183,7 @@ export const addWorkflow = (logger, node, checker, state) => {
     let description;
     let errors;
     let inline;
+    let expose;
     if (ts.isObjectLiteralExpression(firstArg)) {
         const metadata = getCommonWireMetaData(firstArg, 'Workflow', workflowName, logger);
         if (metadata.disabled)
@@ -195,6 +196,7 @@ export const addWorkflow = (logger, node, checker, state) => {
         if (inlineProp === true) {
             inline = true;
         }
+        expose = getPropertyValue(firstArg, 'expose');
     }
     // Validate that we got a valid function
     if (ts.isObjectLiteralExpression(firstArg) &&
@@ -278,5 +280,21 @@ export const addWorkflow = (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/dist/inspector.js

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

package/dist/types.d.ts

@@ -264,6 +264,7 @@ export interface InspectorState {
     singletonServicesFactories: PathToNameAndType;
     wireServicesFactories: PathToNameAndType;
     wireServicesMeta: Map<string, string[]>;
+    addonRequiredParentServices: string[];
     configFactories: PathToNameAndType;
     filesAndMethods: InspectorFilesAndMethods;
     filesAndMethodsErrors: Map<string, PathToNameAndType>;

package/dist/utils/extract-function-name.d.ts

@@ -6,6 +6,7 @@ export type ExtractedFunctionName = {
     exportedName: string | null;
     propertyName: string | null;
     isHelper: boolean;
+    version: number | null;
 };
 export declare function makeContextBasedId(wiringType: string, ...segments: string[]): string;
 export declare function funcIdToTypeName(id: string): string;

package/dist/utils/extract-function-name.js

@@ -1,5 +1,6 @@
 import * as ts from 'typescript';
 import { randomUUID } from 'crypto';
+import { formatVersionedId } from '@pikku/core';
 export function makeContextBasedId(wiringType, ...segments) {
     return [wiringType, ...segments].join(':');
 }
@@ -20,6 +21,7 @@ export function extractFunctionName(callExpr, checker, rootDir) {
         propertyName: null,
         explicitName: null,
         isHelper: false,
+        version: null,
     };
     const workflowHelpers = new Set([
         'workflow',
@@ -103,16 +105,7 @@ export function extractFunctionName(callExpr, checker, rootDir) {
             // Check for object with 'name' property in first argument
             const firstArg = args[0];
             if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-                for (const prop of firstArg.properties) {
-                    if (ts.isPropertyAssignment(prop) &&
-                        ts.isIdentifier(prop.name) &&
-                        prop.name.text === 'override' &&
-                        ts.isStringLiteral(prop.initializer)) {
-                        // Priority 1: Object with override property
-                        result.explicitName = prop.initializer.text;
-                        break;
-                    }
-                }
+                extractOverrideAndVersion(firstArg, result);
             }
             // Special handling for pikkuSessionlessFunc pattern - use the arrow function directly
             if (expression.text.startsWith('pikku')) {
@@ -274,19 +267,9 @@ export function extractFunctionName(callExpr, checker, rootDir) {
                     if (ts.isCallExpression(decl.initializer) &&
                         ts.isIdentifier(decl.initializer.expression) &&
                         decl.initializer.expression.text.startsWith('pikku')) {
-                        // Check for object with 'override' property in first argument
                         const firstArg = decl.initializer.arguments[0];
                         if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-                            for (const prop of firstArg.properties) {
-                                if (ts.isPropertyAssignment(prop) &&
-                                    ts.isIdentifier(prop.name) &&
-                                    prop.name.text === 'override' &&
-                                    ts.isStringLiteral(prop.initializer)) {
-                                    // Priority 1: Object with override property
-                                    result.explicitName = prop.initializer.text;
-                                    break;
-                                }
-                            }
+                            extractOverrideAndVersion(firstArg, result);
                         }
                         if (decl.initializer.expression.text.startsWith('pikku')) {
                             if (firstArg &&
@@ -340,17 +323,7 @@ export function extractFunctionName(callExpr, checker, rootDir) {
     else if (ts.isCallExpression(callExpr)) {
         const firstArg = callExpr.arguments[0];
         if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-            for (const prop of firstArg.properties) {
-                if (ts.isPropertyAssignment(prop) &&
-                    ts.isIdentifier(prop.name) &&
-                    prop.name.text === 'override' &&
-                    ts.isStringLiteral(prop.initializer) &&
-                    !result.explicitName // Only set if not already set
-                ) {
-                    result.explicitName = prop.initializer.text;
-                    break;
-                }
-            }
+            extractOverrideAndVersion(firstArg, result);
         }
     }
     // Apply name priority logic
@@ -364,6 +337,9 @@ export function extractFunctionName(callExpr, checker, rootDir) {
     else {
         result.pikkuFuncId = `__temp_${randomUUID()}`;
     }
+    if (result.version !== null) {
+        result.pikkuFuncId = formatVersionedId(result.pikkuFuncId, result.version);
+    }
     return result;
 }
 /**
@@ -420,3 +396,22 @@ export function isNamedExport(declaration, checker) {
     }
     return false;
 }
+function extractOverrideAndVersion(objLiteral, result) {
+    for (const prop of objLiteral.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+            if (prop.name.text === 'override' &&
+                ts.isStringLiteral(prop.initializer) &&
+                !result.explicitName) {
+                result.explicitName = prop.initializer.text;
+            }
+            else if (prop.name.text === 'version' &&
+                ts.isNumericLiteral(prop.initializer) &&
+                result.version === null) {
+                const parsed = Number(prop.initializer.text);
+                if (Number.isInteger(parsed) && parsed >= 1) {
+                    result.version = parsed;
+                }
+            }
+        }
+    }
+}

package/dist/utils/extract-node-value.js

@@ -84,7 +84,12 @@ export function extractDescription(optionsNode, checker) {
     if (!optionsNode || !ts.isObjectLiteralExpression(optionsNode)) {
         return null;
     }
-    return extractPropertyString(optionsNode, 'description', checker);
+    try {
+        return extractPropertyString(optionsNode, 'description', checker);
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Extract duration value (number or string)