@pikku/inspector 0.11.1 → 0.11.2

package/dist/add/add-workflow.js

@@ -3,8 +3,74 @@ import { extractFunctionName } from '../utils/extract-function-name.js';
 import { extractFunctionNode } from '../utils/extract-function-node.js';
 import { ErrorCode } from '../error-codes.js';
 import { extractStringLiteral, isStringLike, isFunctionLike, extractDescription, extractDuration, } from '../utils/extract-node-value.js';
-import { extractSimpleWorkflow } from '../workflow/extract-simple-workflow.js';
 import { getCommonWireMetaData } from '../utils/get-property-value.js';
+import { extractDSLWorkflow } from '../utils/workflow/dsl/extract-dsl-workflow.js';
+/**
+ * Recursively check if any step has inline type (non-serializable)
+ */
+function hasInlineSteps(steps) {
+    for (const step of steps) {
+        if (step.type === 'inline') {
+            return true;
+        }
+        else if (step.type === 'branch') {
+            for (const branch of step.branches) {
+                if (hasInlineSteps(branch.steps))
+                    return true;
+            }
+            if (step.elseSteps && hasInlineSteps(step.elseSteps))
+                return true;
+        }
+        else if (step.type === 'switch' && step.cases) {
+            for (const c of step.cases) {
+                if (c.steps && hasInlineSteps(c.steps))
+                    return true;
+            }
+            if (step.defaultSteps && hasInlineSteps(step.defaultSteps))
+                return true;
+        }
+        else if (step.type === 'fanout' && step.child) {
+            if (hasInlineSteps([step.child]))
+                return true;
+        }
+        else if (step.type === 'parallel' && step.children) {
+            if (hasInlineSteps(step.children))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Recursively collect all RPC names from workflow steps
+ */
+function collectInvokedRPCs(steps, rpcs) {
+    for (const step of steps) {
+        if (step.type === 'rpc' && step.rpcName) {
+            rpcs.add(step.rpcName);
+        }
+        else if (step.type === 'branch') {
+            for (const branch of step.branches) {
+                collectInvokedRPCs(branch.steps, rpcs);
+            }
+            if (step.elseSteps)
+                collectInvokedRPCs(step.elseSteps, rpcs);
+        }
+        else if (step.type === 'switch' && step.cases) {
+            for (const c of step.cases) {
+                if (c.steps)
+                    collectInvokedRPCs(c.steps, rpcs);
+            }
+            if (step.defaultSteps)
+                collectInvokedRPCs(step.defaultSteps, rpcs);
+        }
+        else if (step.type === 'fanout' && step.child) {
+            collectInvokedRPCs([step.child], rpcs);
+        }
+        else if (step.type === 'parallel' && step.children) {
+            collectInvokedRPCs(step.children, rpcs);
+        }
+    }
+}
 /**
  * Scan for workflow.do(), workflow.sleep(), and workflow.cancel() calls to extract workflow steps
  */
@@ -66,11 +132,10 @@ function getWorkflowInvocations(node, checker, state, workflowName, steps) {
             }
         }
     }
-    // Don't recurse into nested functions - only look at top-level workflow calls
+    // Recurse into children, including arrow functions (for Promise.all callbacks)
+    // but skip function declarations (which would be separate functions)
     ts.forEachChild(node, (child) => {
-        if (ts.isFunctionDeclaration(child) ||
-            ts.isFunctionExpression(child) ||
-            ts.isArrowFunction(child)) {
+        if (ts.isFunctionDeclaration(child)) {
             return;
         }
         getWorkflowInvocations(child, checker, state, workflowName, steps);
@@ -92,10 +157,10 @@ export const addWorkflow = (logger, node, checker, state) => {
     }
     let wrapperType = null;
     if (expression.text === 'pikkuWorkflowFunc') {
-        wrapperType = 'regular';
+        wrapperType = 'dsl';
     }
-    else if (expression.text === 'pikkuSimpleWorkflowFunc') {
-        wrapperType = 'simple';
+    else if (expression.text === 'pikkuWorkflowComplexFunc') {
+        wrapperType = 'regular';
     }
     else {
         return;
@@ -142,34 +207,65 @@ export const addWorkflow = (logger, node, checker, state) => {
         });
     }
     let steps = [];
-    let simple = undefined;
-    // Try simple workflow extraction first
+    let context = undefined;
+    let dsl = undefined;
+    // Try DSL workflow extraction first
     // Pass the whole CallExpression node so findWorkflowFunction can find the arrow function
-    const result = extractSimpleWorkflow(node, checker);
+    const result = extractDSLWorkflow(node, checker);
     if (result.status === 'ok' && result.steps) {
-        // Simple extraction succeeded
+        // Extraction succeeded
         steps = result.steps;
-        simple = true;
+        context = result.context;
+        // Check if workflow contains inline steps (non-serializable)
+        if (hasInlineSteps(steps)) {
+            if (wrapperType === 'dsl') {
+                // pikkuWorkflowFunc should not have inline steps
+                logger.critical(ErrorCode.INVALID_DSL_WORKFLOW, `Workflow '${workflowName}' uses pikkuWorkflowFunc but contains inline steps which are not allowed in DSL workflows. Use pikkuWorkflowComplexFunc instead.`);
+                return;
+            }
+            // pikkuWorkflowComplexFunc with inline steps is marked as non-dsl
+            dsl = false;
+        }
+        else {
+            // pikkuWorkflowComplexFunc is always non-dsl, pikkuWorkflowFunc is dsl
+            dsl = wrapperType === 'dsl';
+        }
+        // Collect all invoked RPCs from workflow steps
+        const rpcs = new Set();
+        collectInvokedRPCs(steps, rpcs);
+        for (const rpc of rpcs) {
+            state.rpc.invokedFunctions.add(rpc);
+        }
     }
     else {
-        // Simple extraction failed
-        if (wrapperType === 'simple') {
-            // For pikkuSimpleWorkflowFunc, this is a critical error
-            logger.critical(ErrorCode.INVALID_SIMPLE_WORKFLOW, `Workflow '${workflowName}' uses pikkuSimpleWorkflowFunc but does not conform to simple workflow DSL:\n${result.reason || 'Unknown error'}`);
+        // DSL extraction failed
+        if (wrapperType === 'dsl') {
+            // For pikkuWorkflowFunc, this is a critical error
+            // But still track RPC invocations for function registration
+            getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps);
+            logger.critical(ErrorCode.INVALID_DSL_WORKFLOW, `Workflow '${workflowName}' uses pikkuWorkflowFunc but does not conform to DSL workflow rules:\n${result.reason || 'Unknown error'}`);
             return;
         }
         else {
-            // For pikkuWorkflowFunc, fall back to basic extraction
-            logger.debug(`Workflow '${workflowName}' could not be extracted as simple workflow: ${result.reason || 'Unknown error'}. Falling back to basic extraction.`);
-            simple = false;
+            // For pikkuWorkflowComplexFunc, fall back to basic extraction
+            logger.debug(`Workflow '${workflowName}' could not be extracted as DSL workflow: ${result.reason || 'Unknown error'}. Falling back to basic extraction.`);
+            dsl = false;
         }
     }
-    getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps);
+    /**
+     * For non-dsl workflows or pikkuWorkflowComplexFunc, run basic extraction
+     * to ensure all RPC invocations are tracked for function registration.
+     * This catches RPCs in Promise.all callbacks and other patterns DSL can't extract.
+     */
+    if (!dsl || wrapperType === 'regular') {
+        getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps);
+    }
     state.workflows.meta[workflowName] = {
         pikkuFuncName,
         workflowName,
         steps,
-        simple,
+        context,
+        dsl,
         summary,
         description,
         errors,

package/dist/error-codes.d.ts

@@ -9,6 +9,7 @@
 export declare enum ErrorCode {
     MISSING_NAME = "PKU111",
     MISSING_DESCRIPTION = "PKU123",
+    INVALID_VALUE = "PKU124",
     MISSING_URI = "PKU220",
     MISSING_FUNC = "PKU236",
     INVALID_TAGS_TYPE = "PKU247",
@@ -19,12 +20,13 @@ export declare enum ErrorCode {
     CLI_CLIENTSIDE_RENDERER_HAS_SERVICES = "PKU672",
     DYNAMIC_STEP_NAME = "PKU529",
     WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED = "PKU600",
-    INVALID_SIMPLE_WORKFLOW = "PKU641",
+    INVALID_DSL_WORKFLOW = "PKU641",
     CONFIG_TYPE_NOT_FOUND = "PKU426",
     CONFIG_TYPE_UNDEFINED = "PKU427",
     SCHEMA_NO_ROOT = "PKU431",
     SCHEMA_GENERATION_ERROR = "PKU456",
     SCHEMA_LOAD_ERROR = "PKU488",
+    INLINE_ZOD_SCHEMA = "PKU489",
     FUNCTION_METADATA_NOT_FOUND = "PKU559",
     HANDLER_NOT_RESOLVED = "PKU568",
     MIDDLEWARE_HANDLER_INVALID = "PKU685",

package/dist/error-codes.js

@@ -11,6 +11,7 @@ export var ErrorCode;
     // Validation errors
     ErrorCode["MISSING_NAME"] = "PKU111";
     ErrorCode["MISSING_DESCRIPTION"] = "PKU123";
+    ErrorCode["INVALID_VALUE"] = "PKU124";
     ErrorCode["MISSING_URI"] = "PKU220";
     ErrorCode["MISSING_FUNC"] = "PKU236";
     ErrorCode["INVALID_TAGS_TYPE"] = "PKU247";
@@ -21,13 +22,14 @@ export var ErrorCode;
     ErrorCode["CLI_CLIENTSIDE_RENDERER_HAS_SERVICES"] = "PKU672";
     ErrorCode["DYNAMIC_STEP_NAME"] = "PKU529";
     ErrorCode["WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED"] = "PKU600";
-    ErrorCode["INVALID_SIMPLE_WORKFLOW"] = "PKU641";
+    ErrorCode["INVALID_DSL_WORKFLOW"] = "PKU641";
     // Configuration errors
     ErrorCode["CONFIG_TYPE_NOT_FOUND"] = "PKU426";
     ErrorCode["CONFIG_TYPE_UNDEFINED"] = "PKU427";
     ErrorCode["SCHEMA_NO_ROOT"] = "PKU431";
     ErrorCode["SCHEMA_GENERATION_ERROR"] = "PKU456";
     ErrorCode["SCHEMA_LOAD_ERROR"] = "PKU488";
+    ErrorCode["INLINE_ZOD_SCHEMA"] = "PKU489";
     // Function errors
     ErrorCode["FUNCTION_METADATA_NOT_FOUND"] = "PKU559";
     ErrorCode["HANDLER_NOT_RESOLVED"] = "PKU568";

package/dist/index.d.ts

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

package/dist/index.js

@@ -4,3 +4,5 @@ export { ErrorCode } from './error-codes.js';
 export { serializeInspectorState, deserializeInspectorState, } from './utils/serialize-inspector-state.js';
 export { filterInspectorState } from './utils/filter-inspector-state.js';
 export { writeAllServiceMetadata } from './utils/write-service-metadata.js';
+export { convertAllDslToGraphs, convertDslToGraph, } from './utils/workflow/graph/convert-dsl-to-graph.js';
+export { deserializeDslWorkflow, deserializeGraphWorkflow, deserializeAllDslWorkflows, } from './utils/workflow/dsl/deserialize-dsl-workflow.js';

package/dist/inspector.js

@@ -24,6 +24,7 @@ export function getInitialInspectorState(rootDir) {
         filesAndMethods: {},
         filesAndMethodsErrors: new Map(),
         typesLookup: new Map(),
+        zodLookup: new Map(),
         functions: {
             typesMap: new TypesMap(),
             meta: {},
@@ -59,6 +60,8 @@ export function getInitialInspectorState(rootDir) {
         workflows: {
             meta: {},
             files: new Map(),
+            graphMeta: {},
+            graphFiles: new Map(),
         },
         rpc: {
             internalMeta: {},
@@ -66,6 +69,7 @@ export function getInitialInspectorState(rootDir) {
             exposedMeta: {},
             exposedFiles: new Map(),
             invokedFunctions: new Set(),
+            usedExternalPackages: new Set(),
         },
         mcpEndpoints: {
             resourcesMeta: {},
@@ -80,6 +84,14 @@ export function getInitialInspectorState(rootDir) {
             },
             files: new Set(),
         },
+        forgeNodes: {
+            meta: {},
+            files: new Set(),
+        },
+        forgeCredentials: {
+            meta: {},
+            files: new Set(),
+        },
         middleware: {
             meta: {},
             tagMiddleware: new Map(),
@@ -115,11 +127,15 @@ export const inspect = (logger, routeFiles, options = {}) => {
     const startChecker = performance.now();
     const checker = program.getTypeChecker();
     logger.debug(`Got type checker in ${(performance.now() - startChecker).toFixed(2)}ms`);
+    // Use provided rootDir or infer from source files
+    const rootDir = options.rootDir || findCommonAncestor(routeFiles);
     const startSourceFiles = performance.now();
-    const sourceFiles = program.getSourceFiles();
+    // Filter source files to only include files within the project rootDir
+    // This prevents picking up types from external packages (including workspace symlinks)
+    const sourceFiles = program
+        .getSourceFiles()
+        .filter((sf) => sf.fileName.startsWith(rootDir));
     logger.debug(`Got source files in ${(performance.now() - startSourceFiles).toFixed(2)}ms`);
-    // Infer root directory from source files
-    const rootDir = findCommonAncestor(routeFiles);
     const state = getInitialInspectorState(rootDir);
     // First sweep: add all functions
     const startSetup = performance.now();

package/dist/types.d.ts

@@ -6,9 +6,11 @@ import { QueueWorkersMeta } from '@pikku/core/queue';
 import { WorkflowsMeta } from '@pikku/core/workflow';
 import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp';
 import { CLIMeta } from '@pikku/core/cli';
+import { ForgeNodesMeta, ForgeCredentialsMeta } from '@pikku/core/forge-node';
 import { TypesMap } from './types-map.js';
 import { FunctionsMeta, FunctionServicesMeta } from '@pikku/core';
 import { ErrorCode } from './error-codes.js';
+import type { SerializedWorkflowGraphs } from './utils/workflow/graph/workflow-graph.types.js';
 export type PathToNameAndType = Map<string, {
     variable: string;
     type: string | null;
@@ -42,6 +44,13 @@ export interface InspectorHTTPState {
     routeMiddleware: Map<string, MiddlewareGroupMeta>;
     routePermissions: Map<string, PermissionGroupMeta>;
 }
+/**
+ * Zod schema reference for deferred conversion to JSON Schema at build time
+ */
+export interface ZodSchemaRef {
+    variableName: string;
+    sourceFile: string;
+}
 export interface InspectorFunctionState {
     typesMap: TypesMap;
     meta: FunctionsMeta;
@@ -88,6 +97,8 @@ export type InspectorFilters = {
 };
 export type InspectorOptions = Partial<{
     setupOnly: boolean;
+    /** Project root directory - used to filter out external package files */
+    rootDir: string;
     types: Partial<{
         configFileType: string;
         userSessionType: string;
@@ -161,6 +172,7 @@ export interface InspectorState {
     filesAndMethods: InspectorFilesAndMethods;
     filesAndMethodsErrors: Map<string, PathToNameAndType>;
     typesLookup: Map<string, ts.Type[]>;
+    zodLookup: Map<string, ZodSchemaRef>;
     http: InspectorHTTPState;
     functions: InspectorFunctionState;
     channels: InspectorChannelState;
@@ -178,6 +190,11 @@ export interface InspectorState {
             path: string;
             exportedName: string;
         }>;
+        graphMeta: SerializedWorkflowGraphs;
+        graphFiles: Map<string, {
+            path: string;
+            exportedName: string;
+        }>;
     };
     rpc: {
         internalMeta: Record<string, string>;
@@ -191,6 +208,7 @@ export interface InspectorState {
             exportedName: string;
         }>;
         invokedFunctions: Set<string>;
+        usedExternalPackages: Set<string>;
     };
     mcpEndpoints: {
         resourcesMeta: MCPResourceMeta;
@@ -202,6 +220,14 @@ export interface InspectorState {
         meta: CLIMeta;
         files: Set<string>;
     };
+    forgeNodes: {
+        meta: ForgeNodesMeta;
+        files: Set<string>;
+    };
+    forgeCredentials: {
+        meta: ForgeCredentialsMeta;
+        files: Set<string>;
+    };
     middleware: InspectorMiddlewareState;
     permissions: InspectorPermissionState;
     serviceAggregation: {

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

@@ -274,9 +274,9 @@ export function extractFunctionName(callExpr, checker, rootDir) {
                 for (const prop of firstArg.properties) {
                     if (ts.isPropertyAssignment(prop) &&
                         ts.isIdentifier(prop.name) &&
-                        prop.name.text === 'name' &&
+                        prop.name.text === 'override' &&
                         ts.isStringLiteral(prop.initializer)) {
-                        // Priority 1: Object with name property
+                        // Priority 1: Object with override property
                         result.explicitName = prop.initializer.text;
                         break;
                     }
@@ -475,15 +475,15 @@ export function extractFunctionName(callExpr, checker, rootDir) {
                         // Update originalCallExpr to use the call expression position
                         // instead of the variable declaration position
                         originalCallExpr = decl.initializer;
-                        // Check for object with 'name' property in first argument
+                        // 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 === 'name' &&
+                                    prop.name.text === 'override' &&
                                     ts.isStringLiteral(prop.initializer)) {
-                                    // Priority 1: Object with name property
+                                    // Priority 1: Object with override property
                                     result.explicitName = prop.initializer.text;
                                     break;
                                 }
@@ -558,14 +558,14 @@ export function extractFunctionName(callExpr, checker, rootDir) {
         ts.isIdentifier(parent.name)) {
         result.propertyName = parent.name.text;
     }
-    // 3) Handle any remaining cases for pikkuFunc({ name: '…', func: … })
+    // 3) Handle any remaining cases for pikkuFunc({ override: '…', func: … })
     else if (ts.isCallExpression(originalCallExpr)) {
         const firstArg = originalCallExpr.arguments[0];
         if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
             for (const prop of firstArg.properties) {
                 if (ts.isPropertyAssignment(prop) &&
                     ts.isIdentifier(prop.name) &&
-                    prop.name.text === 'name' &&
+                    prop.name.text === 'override' &&
                     ts.isStringLiteral(prop.initializer) &&
                     !result.explicitName // Only set if not already set
                 ) {

package/dist/utils/get-property-value.d.ts

@@ -2,7 +2,7 @@ import * as ts from 'typescript';
 import { ErrorCode } from '../error-codes.js';
 export declare const getPropertyValue: (obj: ts.ObjectLiteralExpression, propertyName: string) => string | string[] | null | boolean;
 /**
- * Extracts common wire metadata (tags, summary, description, errors) directly from an object
+ * Extracts common wire metadata (title, tags, summary, description, errors) directly from an object
  * @param obj - The TypeScript object literal expression to extract metadata from
  * @param wiringType - The type of wiring (e.g., 'HTTP route', 'Channel', 'Queue worker')
  * @param wiringName - The name/identifier of the wiring (e.g., route path, channel name)
@@ -12,6 +12,7 @@ export declare const getPropertyValue: (obj: ts.ObjectLiteralExpression, propert
 export declare const getCommonWireMetaData: (obj: ts.ObjectLiteralExpression, wiringType: string, wiringName: string | null, logger?: {
     critical: (code: ErrorCode, message: string) => void;
 }) => {
+    title?: string;
     tags?: string[];
     summary?: string;
     description?: string;

package/dist/utils/get-property-value.js

@@ -37,7 +37,7 @@ export const getPropertyValue = (obj, propertyName) => {
     return null;
 };
 /**
- * Extracts common wire metadata (tags, summary, description, errors) directly from an object
+ * Extracts common wire metadata (title, tags, summary, description, errors) directly from an object
  * @param obj - The TypeScript object literal expression to extract metadata from
  * @param wiringType - The type of wiring (e.g., 'HTTP route', 'Channel', 'Queue worker')
  * @param wiringName - The name/identifier of the wiring (e.g., route path, channel name)
@@ -49,7 +49,11 @@ export const getCommonWireMetaData = (obj, wiringType, wiringName, logger) => {
     obj.properties.forEach((prop) => {
         if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
             const propName = prop.name.text;
-            if (propName === 'summary' && ts.isStringLiteral(prop.initializer)) {
+            if (propName === 'title' && ts.isStringLiteral(prop.initializer)) {
+                metadata.title = prop.initializer.text;
+            }
+            else if (propName === 'summary' &&
+                ts.isStringLiteral(prop.initializer)) {
                 metadata.summary = prop.initializer.text;
             }
             else if (propName === 'description' &&

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

@@ -74,6 +74,10 @@ export interface SerializableInspectorState {
             }[]
         ]>
     ]>;
+    zodLookup: Array<[string, {
+        variableName: string;
+        sourceFile: string;
+    }]>;
     functions: {
         typesMap: {
             map: Array<[string, {
@@ -129,6 +133,11 @@ export interface SerializableInspectorState {
             path: string;
             exportedName: string;
         }]>;
+        graphMeta: InspectorState['workflows']['graphMeta'];
+        graphFiles: Array<[string, {
+            path: string;
+            exportedName: string;
+        }]>;
     };
     rpc: {
         internalMeta: InspectorState['rpc']['internalMeta'];
@@ -142,6 +151,7 @@ export interface SerializableInspectorState {
             exportedName: string;
         }]>;
         invokedFunctions: string[];
+        usedExternalPackages: string[];
     };
     mcpEndpoints: {
         resourcesMeta: InspectorState['mcpEndpoints']['resourcesMeta'];
@@ -153,6 +163,14 @@ export interface SerializableInspectorState {
         meta: InspectorState['cli']['meta'];
         files: string[];
     };
+    forgeNodes: {
+        meta: InspectorState['forgeNodes']['meta'];
+        files: string[];
+    };
+    forgeCredentials: {
+        meta: InspectorState['forgeCredentials']['meta'];
+        files: string[];
+    };
     middleware: {
         meta: InspectorState['middleware']['meta'];
         tagMiddleware: Array<[
@@ -195,4 +213,9 @@ export declare function serializeInspectorState(state: InspectorState): Serializ
  * Deserializes JSON data back to InspectorState
  * Creates a partial state suitable for filtering/generation (without typesLookup)
  */
-export declare function deserializeInspectorState(data: SerializableInspectorState): Omit<InspectorState, 'typesLookup'>;
+export declare function deserializeInspectorState(data: SerializableInspectorState): Omit<InspectorState, 'typesLookup' | 'zodLookup'> & {
+    zodLookup: Map<string, {
+        variableName: string;
+        sourceFile: string;
+    }>;
+};

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

@@ -26,6 +26,7 @@ export function serializeInspectorState(state) {
         configFactories: Array.from(state.configFactories.entries()),
         filesAndMethods: state.filesAndMethods,
         filesAndMethodsErrors: Array.from(state.filesAndMethodsErrors.entries()).map(([key, mapValue]) => [key, Array.from(mapValue.entries())]),
+        zodLookup: Array.from(state.zodLookup.entries()),
         functions: {
             typesMap: serializeTypesMap(state.functions.typesMap),
             meta: state.functions.meta,
@@ -53,6 +54,8 @@ export function serializeInspectorState(state) {
         workflows: {
             meta: state.workflows.meta,
             files: Array.from(state.workflows.files.entries()),
+            graphMeta: state.workflows.graphMeta,
+            graphFiles: Array.from(state.workflows.graphFiles.entries()),
         },
         rpc: {
             internalMeta: state.rpc.internalMeta,
@@ -60,6 +63,7 @@ export function serializeInspectorState(state) {
             exposedMeta: state.rpc.exposedMeta,
             exposedFiles: Array.from(state.rpc.exposedFiles.entries()),
             invokedFunctions: Array.from(state.rpc.invokedFunctions),
+            usedExternalPackages: Array.from(state.rpc.usedExternalPackages),
         },
         mcpEndpoints: {
             resourcesMeta: state.mcpEndpoints.resourcesMeta,
@@ -71,6 +75,14 @@ export function serializeInspectorState(state) {
             meta: state.cli.meta,
             files: Array.from(state.cli.files),
         },
+        forgeNodes: {
+            meta: state.forgeNodes.meta,
+            files: Array.from(state.forgeNodes.files),
+        },
+        forgeCredentials: {
+            meta: state.forgeCredentials.meta,
+            files: Array.from(state.forgeCredentials.files),
+        },
         middleware: {
             meta: state.middleware.meta,
             tagMiddleware: Array.from(state.middleware.tagMiddleware.entries()),
@@ -118,6 +130,7 @@ export function deserializeInspectorState(data) {
             key,
             new Map(entries),
         ])),
+        zodLookup: new Map(data.zodLookup || []),
         functions: {
             typesMap: deserializeTypesMap(data.functions.typesMap),
             meta: data.functions.meta,
@@ -145,6 +158,8 @@ export function deserializeInspectorState(data) {
         workflows: {
             meta: data.workflows.meta,
             files: new Map(data.workflows.files),
+            graphMeta: data.workflows.graphMeta || {},
+            graphFiles: new Map(data.workflows.graphFiles || []),
         },
         rpc: {
             internalMeta: data.rpc.internalMeta,
@@ -152,6 +167,7 @@ export function deserializeInspectorState(data) {
             exposedMeta: data.rpc.exposedMeta,
             exposedFiles: new Map(data.rpc.exposedFiles),
             invokedFunctions: new Set(data.rpc.invokedFunctions),
+            usedExternalPackages: new Set(data.rpc.usedExternalPackages || []),
         },
         mcpEndpoints: {
             resourcesMeta: data.mcpEndpoints.resourcesMeta,
@@ -163,6 +179,14 @@ export function deserializeInspectorState(data) {
             meta: data.cli.meta,
             files: new Set(data.cli.files),
         },
+        forgeNodes: {
+            meta: data.forgeNodes?.meta || {},
+            files: new Set(data.forgeNodes?.files || []),
+        },
+        forgeCredentials: {
+            meta: data.forgeCredentials?.meta || {},
+            files: new Set(data.forgeCredentials?.files || []),
+        },
         middleware: {
             meta: data.middleware.meta,
             tagMiddleware: new Map(data.middleware.tagMiddleware),

package/dist/utils/workflow/dsl/deserialize-dsl-workflow.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Deserialize workflow JSON back to DSL code
+ * Converts the serialized workflow graph format back to TypeScript DSL code
+ */
+import type { SerializedWorkflowGraph } from '../graph/workflow-graph.types.js';
+interface DeserializeOptions {
+    /** Import path for pikkuWorkflowFunc */
+    pikkuImportPath?: string;
+    /** Whether to include type annotations */
+    includeTypes?: boolean;
+}
+/**
+ * Deserialize a workflow graph to DSL code
+ */
+export declare function deserializeDslWorkflow(workflow: SerializedWorkflowGraph, options?: DeserializeOptions): string;
+/**
+ * Deserialize a graph workflow to pikkuWorkflowGraph code
+ */
+export declare function deserializeGraphWorkflow(workflow: SerializedWorkflowGraph, options?: DeserializeOptions): string;
+/**
+ * Deserialize all workflows from JSON to DSL code
+ */
+export declare function deserializeAllDslWorkflows(workflows: Record<string, SerializedWorkflowGraph>, options?: DeserializeOptions): Record<string, string>;
+export {};