@pikku/inspector 0.11.2 → 0.12.0

package/dist/add/add-workflow.js

@@ -169,7 +169,7 @@ export const addWorkflow = (logger, node, checker, state) => {
         return;
     }
     // Extract workflow name and metadata using same logic as add-functions
-    const { pikkuFuncName, name, exportedName } = extractFunctionName(node, checker, state.rootDir);
+    const { pikkuFuncId, name, exportedName } = extractFunctionName(node, checker, state.rootDir);
     const workflowName = exportedName || name;
     if (!workflowName) {
         logger.critical(ErrorCode.MISSING_NAME, `Could not determine workflow name from export.`);
@@ -184,6 +184,8 @@ export const addWorkflow = (logger, node, checker, state) => {
     let errors;
     if (ts.isObjectLiteralExpression(firstArg)) {
         const metadata = getCommonWireMetaData(firstArg, 'Workflow', workflowName, logger);
+        if (metadata.disabled)
+            return;
         tags = metadata.tags;
         summary = metadata.summary;
         description = metadata.description;
@@ -201,7 +203,7 @@ export const addWorkflow = (logger, node, checker, state) => {
     }
     // Track workflow file for wiring generation
     if (exportedName) {
-        state.workflows.files.set(pikkuFuncName, {
+        state.workflows.files.set(pikkuFuncId, {
             path: node.getSourceFile().fileName,
             exportedName,
         });
@@ -261,8 +263,8 @@ export const addWorkflow = (logger, node, checker, state) => {
         getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps);
     }
     state.workflows.meta[workflowName] = {
-        pikkuFuncName,
-        workflowName,
+        pikkuFuncId,
+        name: workflowName,
         steps,
         context,
         dsl,

package/dist/error-codes.d.ts

@@ -26,9 +26,11 @@ export declare enum ErrorCode {
     SCHEMA_NO_ROOT = "PKU431",
     SCHEMA_GENERATION_ERROR = "PKU456",
     SCHEMA_LOAD_ERROR = "PKU488",
-    INLINE_ZOD_SCHEMA = "PKU489",
+    INLINE_SCHEMA = "PKU489",
     FUNCTION_METADATA_NOT_FOUND = "PKU559",
     HANDLER_NOT_RESOLVED = "PKU568",
+    ROUTE_PARAM_MISMATCH = "PKU571",
+    ROUTE_QUERY_MISMATCH = "PKU572",
     MIDDLEWARE_HANDLER_INVALID = "PKU685",
     MIDDLEWARE_TAG_INVALID = "PKU715",
     MIDDLEWARE_EMPTY_ARRAY = "PKU736",
@@ -37,5 +39,16 @@ export declare enum ErrorCode {
     PERMISSION_TAG_INVALID = "PKU836",
     PERMISSION_EMPTY_ARRAY = "PKU937",
     PERMISSION_PATTERN_INVALID = "PKU975",
+    DUPLICATE_FUNCTION_VERSION = "PKU850",
+    MANIFEST_MISSING = "PKU860",
+    FUNCTION_VERSION_MODIFIED = "PKU861",
+    CONTRACT_CHANGED_REQUIRES_BUMP = "PKU862",
+    VERSION_REGRESSION_OR_CONFLICT = "PKU863",
+    VERSION_GAP_NOT_ALLOWED = "PKU864",
+    MANIFEST_INTEGRITY_ERROR = "PKU865",
+    MISSING_MODEL = "PKU145",
+    INVALID_MODEL = "PKU146",
+    SERVICES_NOT_DESTRUCTURED = "PKU410",
+    WIRES_NOT_DESTRUCTURED = "PKU411",
     WORKFLOW_MULTI_QUEUE_NOT_SUPPORTED = "PKU901"
 }

package/dist/error-codes.js

@@ -29,10 +29,13 @@ export var ErrorCode;
     ErrorCode["SCHEMA_NO_ROOT"] = "PKU431";
     ErrorCode["SCHEMA_GENERATION_ERROR"] = "PKU456";
     ErrorCode["SCHEMA_LOAD_ERROR"] = "PKU488";
-    ErrorCode["INLINE_ZOD_SCHEMA"] = "PKU489";
+    ErrorCode["INLINE_SCHEMA"] = "PKU489";
     // Function errors
     ErrorCode["FUNCTION_METADATA_NOT_FOUND"] = "PKU559";
     ErrorCode["HANDLER_NOT_RESOLVED"] = "PKU568";
+    // HTTP Route errors
+    ErrorCode["ROUTE_PARAM_MISMATCH"] = "PKU571";
+    ErrorCode["ROUTE_QUERY_MISMATCH"] = "PKU572";
     // Middleware/Permission errors
     ErrorCode["MIDDLEWARE_HANDLER_INVALID"] = "PKU685";
     ErrorCode["MIDDLEWARE_TAG_INVALID"] = "PKU715";
@@ -42,6 +45,21 @@ export var ErrorCode;
     ErrorCode["PERMISSION_TAG_INVALID"] = "PKU836";
     ErrorCode["PERMISSION_EMPTY_ARRAY"] = "PKU937";
     ErrorCode["PERMISSION_PATTERN_INVALID"] = "PKU975";
+    // Versioning errors
+    ErrorCode["DUPLICATE_FUNCTION_VERSION"] = "PKU850";
+    // Contract versioning errors
+    ErrorCode["MANIFEST_MISSING"] = "PKU860";
+    ErrorCode["FUNCTION_VERSION_MODIFIED"] = "PKU861";
+    ErrorCode["CONTRACT_CHANGED_REQUIRES_BUMP"] = "PKU862";
+    ErrorCode["VERSION_REGRESSION_OR_CONFLICT"] = "PKU863";
+    ErrorCode["VERSION_GAP_NOT_ALLOWED"] = "PKU864";
+    ErrorCode["MANIFEST_INTEGRITY_ERROR"] = "PKU865";
+    // Model configuration errors
+    ErrorCode["MISSING_MODEL"] = "PKU145";
+    ErrorCode["INVALID_MODEL"] = "PKU146";
+    // Optimization diagnostics
+    ErrorCode["SERVICES_NOT_DESTRUCTURED"] = "PKU410";
+    ErrorCode["WIRES_NOT_DESTRUCTURED"] = "PKU411";
     // Feature Flag
     ErrorCode["WORKFLOW_MULTI_QUEUE_NOT_SUPPORTED"] = "PKU901";
 })(ErrorCode || (ErrorCode = {}));

package/dist/index.d.ts

@@ -1,15 +1,16 @@
 export { inspect, getInitialInspectorState } from './inspector.js';
-export { getFilesAndMethods } from './utils/get-files-and-methods.js';
 export type { TypesMap } from './types-map.js';
 export type * from './types.js';
-export type { InspectorState } from './types.js';
-export type { FilesAndMethods, FilesAndMethodsErrors, } from './utils/get-files-and-methods.js';
+export type { FilesAndMethodsErrors } from './utils/get-files-and-methods.js';
 export { ErrorCode } from './error-codes.js';
 export { serializeInspectorState, deserializeInspectorState, } from './utils/serialize-inspector-state.js';
 export type { SerializableInspectorState } from './utils/serialize-inspector-state.js';
 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';
+export { generateCustomTypes, sanitizeTypeName, } from './utils/custom-types-generator.js';
+export { createEmptyManifest, serializeManifest, } from './utils/contract-hashes.js';
+export type { ContractEntry, VersionValidateError, VersionManifest, VersionManifestEntry, } from './utils/contract-hashes.js';
+export { serializeMCPJson } from './utils/serialize-mcp-json.js';
+export type { OpenAPISpecInfo } from './utils/serialize-openapi-json.js';
+export { deserializeDslWorkflow, deserializeGraphWorkflow, deserializeAllDslWorkflows, } from './utils/workflow/dsl/index.js';
+export { getFilesAndMethods } from './utils/get-files-and-methods.js';
+export type { SerializedWorkflowGraph, SerializedWorkflowGraphs, } from './utils/workflow/graph/index.js';

package/dist/index.js

@@ -1,8 +1,9 @@
 export { inspect, getInitialInspectorState } from './inspector.js';
-export { getFilesAndMethods } from './utils/get-files-and-methods.js';
 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';
+export { generateCustomTypes, sanitizeTypeName, } from './utils/custom-types-generator.js';
+export { createEmptyManifest, serializeManifest, } from './utils/contract-hashes.js';
+export { serializeMCPJson } from './utils/serialize-mcp-json.js';
+export { deserializeDslWorkflow, deserializeGraphWorkflow, deserializeAllDslWorkflows, } from './utils/workflow/dsl/index.js';
+export { getFilesAndMethods } from './utils/get-files-and-methods.js';

package/dist/inspector.d.ts

@@ -5,4 +5,4 @@ import { InspectorState, InspectorLogger, InspectorOptions } from './types.js';
  * @returns A fresh InspectorState with empty collections
  */
 export declare function getInitialInspectorState(rootDir: string): InspectorState;
-export declare const inspect: (logger: InspectorLogger, routeFiles: string[], options?: InspectorOptions) => InspectorState;
+export declare const inspect: (logger: InspectorLogger, routeFiles: string[], options?: InspectorOptions) => Promise<InspectorState>;

package/dist/inspector.js

@@ -4,7 +4,14 @@ import { visitSetup, visitRoutes } from './visit.js';
 import { TypesMap } from './types-map.js';
 import { getFilesAndMethods } from './utils/get-files-and-methods.js';
 import { findCommonAncestor } from './utils/find-root-dir.js';
-import { aggregateRequiredServices, extractServiceInterfaceMetadata, } from './utils/post-process.js';
+import { aggregateRequiredServices, validateSecretOverrides, validateAgentModels, validateAgentOverrides, computeResolvedIOTypes, computeMiddlewareGroupsMeta, computePermissionsGroupsMeta, computeRequiredSchemas, computeDiagnostics, } from './utils/post-process.js';
+import { generateOpenAPISpec } from './utils/serialize-openapi-json.js';
+import { pikkuState } from '@pikku/core';
+import { resolveLatestVersions } from './utils/resolve-versions.js';
+import { finalizeWorkflows } from './utils/workflow/graph/finalize-workflows.js';
+import { finalizeWorkflowHelperTypes, finalizeWorkflowWires, } from './utils/workflow/graph/finalize-workflow-wires.js';
+import { generateAllSchemas } from './utils/schema-generator.js';
+import { computeContractHashes, extractContractsFromMeta, updateManifest, createEmptyManifest, validateContracts, } from './utils/contract-hashes.js';
 /**
  * Creates an initial/empty inspector state with all required properties initialized
  * @param rootDir - The root directory for the project
@@ -24,7 +31,8 @@ export function getInitialInspectorState(rootDir) {
         filesAndMethods: {},
         filesAndMethodsErrors: new Map(),
         typesLookup: new Map(),
-        zodLookup: new Map(),
+        schemaLookup: new Map(),
+        schemas: {},
         functions: {
             typesMap: new TypesMap(),
             meta: {},
@@ -49,6 +57,11 @@ export function getInitialInspectorState(rootDir) {
             files: new Set(),
             meta: {},
         },
+        triggers: {
+            meta: {},
+            sourceMeta: {},
+            files: new Set(),
+        },
         scheduledTasks: {
             meta: {},
             files: new Set(),
@@ -62,6 +75,7 @@ export function getInitialInspectorState(rootDir) {
             files: new Map(),
             graphMeta: {},
             graphFiles: new Map(),
+            invokedWorkflows: new Set(),
         },
         rpc: {
             internalMeta: {},
@@ -77,6 +91,10 @@ export function getInitialInspectorState(rootDir) {
             promptsMeta: {},
             files: new Set(),
         },
+        agents: {
+            agentsMeta: {},
+            files: new Map(),
+        },
         cli: {
             meta: {
                 programs: {},
@@ -84,20 +102,39 @@ export function getInitialInspectorState(rootDir) {
             },
             files: new Set(),
         },
-        forgeNodes: {
+        nodes: {
             meta: {},
             files: new Set(),
         },
-        forgeCredentials: {
-            meta: {},
+        secrets: {
+            definitions: [],
+            files: new Set(),
+        },
+        variables: {
+            definitions: [],
             files: new Set(),
         },
+        manifest: {
+            initial: null,
+            current: null,
+            errors: [],
+        },
         middleware: {
-            meta: {},
+            definitions: {},
+            instances: {},
             tagMiddleware: new Map(),
         },
+        channelMiddleware: {
+            definitions: {},
+            instances: {},
+            tagMiddleware: new Map(),
+        },
+        aiMiddleware: {
+            definitions: {},
+        },
         permissions: {
-            meta: {},
+            definitions: {},
+            instances: {},
             tagPermissions: new Map(),
         },
         serviceAggregation: {
@@ -108,17 +145,36 @@ export function getInitialInspectorState(rootDir) {
             allSingletonServices: [],
             allWireServices: [],
         },
-        serviceMetadata: [],
+        resolvedIOTypes: {},
+        middlewareGroupsMeta: {
+            definitions: {},
+            instances: {},
+            httpGroups: {},
+            tagGroups: {},
+            channelMiddleware: {
+                definitions: {},
+                instances: {},
+                tagGroups: {},
+            },
+        },
+        permissionsGroupsMeta: {
+            definitions: {},
+            httpGroups: {},
+            tagGroups: {},
+        },
+        requiredSchemas: new Set(),
+        openAPISpec: null,
+        diagnostics: [],
     };
 }
-export const inspect = (logger, routeFiles, options = {}) => {
+export const inspect = async (logger, routeFiles, options = {}) => {
     const startProgram = performance.now();
     const program = ts.createProgram(routeFiles, {
         target: ts.ScriptTarget.ESNext,
-        module: ts.ModuleKind.CommonJS,
+        module: ts.ModuleKind.Node16,
         skipLibCheck: true,
         skipDefaultLibCheck: true,
-        moduleResolution: ts.ModuleResolutionKind.Node10,
+        moduleResolution: ts.ModuleResolutionKind.Node16,
         types: [],
         allowJs: false,
         checkJs: false,
@@ -150,6 +206,20 @@ export const inspect = (logger, routeFiles, options = {}) => {
             ts.forEachChild(sourceFile, (child) => visitRoutes(logger, checker, child, state, options));
         }
         logger.debug(`Visit routes phase completed in ${(performance.now() - startRoutes).toFixed(2)}ms`);
+        resolveLatestVersions(state, logger);
+        if (options.schemaConfig) {
+            state.schemas = await generateAllSchemas(logger, options.schemaConfig, state);
+            computeContractHashes(state.schemas, state.functions.typesMap, state.functions.meta);
+            computeRequiredSchemas(state, options);
+        }
+        state.manifest.initial = options.manifest ?? null;
+        const contracts = extractContractsFromMeta(state.functions.meta);
+        const baseManifest = state.manifest.initial ?? createEmptyManifest();
+        state.manifest.current = updateManifest(baseManifest, contracts);
+        state.manifest.errors = validateContracts(baseManifest, contracts).errors;
+        finalizeWorkflows(state);
+        finalizeWorkflowHelperTypes(state);
+        finalizeWorkflowWires(state);
     }
     // Populate filesAndMethods
     const startFilesAndMethods = performance.now();
@@ -161,9 +231,16 @@ export const inspect = (logger, routeFiles, options = {}) => {
         const startAggregate = performance.now();
         aggregateRequiredServices(state);
         logger.debug(`Aggregate required services completed in ${(performance.now() - startAggregate).toFixed(2)}ms`);
-        const startServiceMeta = performance.now();
-        extractServiceInterfaceMetadata(state, checker);
-        logger.debug(`Extract service metadata completed in ${(performance.now() - startServiceMeta).toFixed(2)}ms`);
+        computeResolvedIOTypes(state);
+        computeMiddlewareGroupsMeta(state);
+        computePermissionsGroupsMeta(state);
+        computeDiagnostics(state);
+        if (options.openAPI) {
+            state.openAPISpec = await generateOpenAPISpec(logger, state.functions.meta, state.http.meta, state.schemas, options.openAPI.additionalInfo, pikkuState(null, 'misc', 'errors'));
+        }
+        validateSecretOverrides(logger, state, options.externalPackages);
+        validateAgentModels(logger, state, options.modelConfig);
+        validateAgentOverrides(logger, state, options.modelConfig);
     }
     return state;
 };

package/dist/schema-generator.d.ts

@@ -0,0 +1 @@
+export { generateAllSchemas } from './utils/schema-generator.js';

package/dist/schema-generator.js

@@ -0,0 +1 @@
+export { generateAllSchemas } from './utils/schema-generator.js';

package/dist/types-map.js

@@ -17,7 +17,16 @@ export class TypesMap {
         return meta.uniqueName;
     }
     getTypeMeta(name) {
-        if (['string', 'number', 'boolean', 'null'].includes(name)) {
+        if ([
+            'string',
+            'number',
+            'boolean',
+            'null',
+            'undefined',
+            'void',
+            'unknown',
+            'never',
+        ].includes(name)) {
             return {
                 originalName: name,
                 uniqueName: name,

package/dist/types.d.ts

@@ -2,14 +2,20 @@ import * as ts from 'typescript';
 import { ChannelsMeta } from '@pikku/core/channel';
 import { HTTPWiringsMeta } from '@pikku/core/http';
 import { ScheduledTasksMeta } from '@pikku/core/scheduler';
+import { TriggerMeta, TriggerSourceMeta } from '@pikku/core/trigger';
 import { QueueWorkersMeta } from '@pikku/core/queue';
 import { WorkflowsMeta } from '@pikku/core/workflow';
 import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp';
+import { AIAgentMeta } from '@pikku/core/ai-agent';
 import { CLIMeta } from '@pikku/core/cli';
-import { ForgeNodesMeta, ForgeCredentialsMeta } from '@pikku/core/forge-node';
+import { NodesMeta } from '@pikku/core/node';
+import { SecretDefinitions } from '@pikku/core/secret';
+import { VariableDefinitions } from '@pikku/core/variable';
 import { TypesMap } from './types-map.js';
-import { FunctionsMeta, FunctionServicesMeta } from '@pikku/core';
+import { FunctionsMeta, FunctionServicesMeta, FunctionWiresMeta, JSONValue } from '@pikku/core';
+import type { OpenAPISpecInfo } from './utils/serialize-openapi-json.js';
 import { ErrorCode } from './error-codes.js';
+import type { VersionManifest, VersionValidateError } from './utils/contract-hashes.js';
 import type { SerializedWorkflowGraphs } from './utils/workflow/graph/workflow-graph.types.js';
 export type PathToNameAndType = Map<string, {
     variable: string;
@@ -26,7 +32,8 @@ export interface MiddlewareGroupMeta {
     sourceFile: string;
     position: number;
     services: FunctionServicesMeta;
-    middlewareCount: number;
+    count: number;
+    instanceIds: string[];
     isFactory: boolean;
 }
 export interface PermissionGroupMeta {
@@ -34,7 +41,8 @@ export interface PermissionGroupMeta {
     sourceFile: string;
     position: number;
     services: FunctionServicesMeta;
-    permissionCount: number;
+    count: number;
+    instanceIds: string[];
     isFactory: boolean;
 }
 export interface InspectorHTTPState {
@@ -45,11 +53,17 @@ export interface InspectorHTTPState {
     routePermissions: Map<string, PermissionGroupMeta>;
 }
 /**
- * Zod schema reference for deferred conversion to JSON Schema at build time
+ * Schema vendor types for Standard Schema compliant validators
  */
-export interface ZodSchemaRef {
+export type SchemaVendor = 'zod' | 'valibot' | 'arktype' | 'effect' | 'unknown';
+/**
+ * Schema reference for deferred conversion to JSON Schema at build time.
+ * Supports Standard Schema compliant validators (Zod, Valibot, ArkType, Effect Schema).
+ */
+export interface SchemaRef {
     variableName: string;
     sourceFile: string;
+    vendor?: SchemaVendor;
 }
 export interface InspectorFunctionState {
     typesMap: TypesMap;
@@ -63,28 +77,57 @@ export interface InspectorChannelState {
     meta: ChannelsMeta;
     files: Set<string>;
 }
+export interface InspectorMiddlewareDefinition {
+    services: FunctionServicesMeta;
+    wires?: FunctionWiresMeta;
+    sourceFile: string;
+    position: number;
+    exportedName: string | null;
+    factory?: boolean;
+    name?: string;
+    description?: string;
+    package?: string;
+}
+export interface InspectorMiddlewareInstance {
+    definitionId: string;
+    sourceFile: string;
+    position: number;
+    isFactoryCall: boolean;
+}
 export interface InspectorMiddlewareState {
-    meta: Record<string, {
-        services: FunctionServicesMeta;
-        sourceFile: string;
-        position: number;
-        exportedName: string | null;
-        factory?: boolean;
-        name?: string;
-        description?: string;
-    }>;
+    definitions: Record<string, InspectorMiddlewareDefinition>;
+    instances: Record<string, InspectorMiddlewareInstance>;
+    tagMiddleware: Map<string, MiddlewareGroupMeta>;
+}
+export interface InspectorChannelMiddlewareState {
+    definitions: Record<string, InspectorMiddlewareDefinition>;
+    instances: Record<string, InspectorMiddlewareInstance>;
     tagMiddleware: Map<string, MiddlewareGroupMeta>;
 }
+export interface InspectorAIMiddlewareState {
+    definitions: Record<string, InspectorMiddlewareDefinition>;
+}
+export interface InspectorPermissionDefinition {
+    services: FunctionServicesMeta;
+    wires?: FunctionWiresMeta;
+    sourceFile: string;
+    position: number;
+    exportedName: string | null;
+    factory?: boolean;
+    name?: string;
+    description?: string;
+    package?: string;
+    requiresData?: boolean;
+}
+export interface InspectorPermissionInstance {
+    definitionId: string;
+    sourceFile: string;
+    position: number;
+    isFactoryCall: boolean;
+}
 export interface InspectorPermissionState {
-    meta: Record<string, {
-        services: FunctionServicesMeta;
-        sourceFile: string;
-        position: number;
-        exportedName: string | null;
-        factory?: boolean;
-        name?: string;
-        description?: string;
-    }>;
+    definitions: Record<string, InspectorPermissionDefinition>;
+    instances: Record<string, InspectorPermissionInstance>;
     tagPermissions: Map<string, PermissionGroupMeta>;
 }
 export type InspectorFilters = {
@@ -95,16 +138,53 @@ export type InspectorFilters = {
     httpRoutes?: string[];
     httpMethods?: string[];
 };
+export type ExternalPackageConfig = {
+    package: string;
+    rpcEndpoint?: string;
+    secretOverrides?: Record<string, string>;
+    forceInclude?: boolean;
+};
+export type ModelConfigEntry = string | {
+    model: string;
+    temperature?: number;
+    maxSteps?: number;
+};
+export type InspectorModelConfig = {
+    models?: Record<string, ModelConfigEntry>;
+    agentDefaults?: {
+        temperature?: number;
+        maxSteps?: number;
+    };
+    agentOverrides?: Record<string, {
+        model?: string;
+        temperature?: number;
+        maxSteps?: number;
+    }>;
+};
 export type InspectorOptions = Partial<{
     setupOnly: boolean;
-    /** Project root directory - used to filter out external package files */
     rootDir: string;
+    isExternalPackage: boolean;
     types: Partial<{
         configFileType: string;
         userSessionType: string;
         singletonServicesFactoryType: string;
         wireServicesFactoryType: string;
     }>;
+    externalPackages: Record<string, ExternalPackageConfig>;
+    schemaConfig: {
+        tsconfig: string;
+        schemasFromTypes?: string[];
+        schema?: {
+            additionalProperties?: boolean;
+        };
+    };
+    openAPI: {
+        additionalInfo: OpenAPISpecInfo;
+    };
+    tags: string[];
+    manifest: VersionManifest;
+    modelConfig: InspectorModelConfig;
 }>;
 export interface InspectorLogger {
     info: (message: string) => void;
@@ -159,6 +239,12 @@ export interface InspectorFilesAndMethods {
         typePath: string;
     };
 }
+export interface InspectorDiagnostic {
+    code: string;
+    message: string;
+    sourceFile: string;
+    position: number;
+}
 export interface InspectorState {
     rootDir: string;
     singletonServicesTypeImportMap: PathToNameAndType;
@@ -172,10 +258,16 @@ export interface InspectorState {
     filesAndMethods: InspectorFilesAndMethods;
     filesAndMethodsErrors: Map<string, PathToNameAndType>;
     typesLookup: Map<string, ts.Type[]>;
-    zodLookup: Map<string, ZodSchemaRef>;
+    schemaLookup: Map<string, SchemaRef>;
+    schemas: Record<string, JSONValue>;
     http: InspectorHTTPState;
     functions: InspectorFunctionState;
     channels: InspectorChannelState;
+    triggers: {
+        meta: TriggerMeta;
+        sourceMeta: TriggerSourceMeta;
+        files: Set<string>;
+    };
     scheduledTasks: {
         meta: ScheduledTasksMeta;
         files: Set<string>;
@@ -195,6 +287,7 @@ export interface InspectorState {
             path: string;
             exportedName: string;
         }>;
+        invokedWorkflows: Set<string>;
     };
     rpc: {
         internalMeta: Record<string, string>;
@@ -216,19 +309,37 @@ export interface InspectorState {
         promptsMeta: MCPPromptMeta;
         files: Set<string>;
     };
+    agents: {
+        agentsMeta: AIAgentMeta;
+        files: Map<string, {
+            path: string;
+            exportedName: string;
+        }>;
+    };
     cli: {
         meta: CLIMeta;
         files: Set<string>;
     };
-    forgeNodes: {
-        meta: ForgeNodesMeta;
+    nodes: {
+        meta: NodesMeta;
         files: Set<string>;
     };
-    forgeCredentials: {
-        meta: ForgeCredentialsMeta;
+    secrets: {
+        definitions: SecretDefinitions;
         files: Set<string>;
     };
+    variables: {
+        definitions: VariableDefinitions;
+        files: Set<string>;
+    };
+    manifest: {
+        initial: VersionManifest | null;
+        current: VersionManifest | null;
+        errors: VersionValidateError[];
+    };
     middleware: InspectorMiddlewareState;
+    channelMiddleware: InspectorChannelMiddlewareState;
+    aiMiddleware: InspectorAIMiddlewareState;
     permissions: InspectorPermissionState;
     serviceAggregation: {
         requiredServices: Set<string>;
@@ -238,14 +349,27 @@ export interface InspectorState {
         allSingletonServices: string[];
         allWireServices: string[];
     };
-    serviceMetadata: Array<{
-        name: string;
-        summary: string;
-        description: string;
-        package: string;
-        path: string;
-        version: string;
-        interface: string;
-        expandedProperties: Record<string, string>;
+    resolvedIOTypes: Record<string, {
+        inputType: string;
+        outputType: string;
     }>;
+    middlewareGroupsMeta: {
+        definitions: Record<string, InspectorMiddlewareDefinition>;
+        instances: Record<string, InspectorMiddlewareInstance>;
+        httpGroups: Record<string, MiddlewareGroupMeta>;
+        tagGroups: Record<string, MiddlewareGroupMeta>;
+        channelMiddleware: {
+            definitions: Record<string, InspectorMiddlewareDefinition>;
+            instances: Record<string, InspectorMiddlewareInstance>;
+            tagGroups: Record<string, MiddlewareGroupMeta>;
+        };
+    };
+    permissionsGroupsMeta: {
+        definitions: Record<string, InspectorPermissionDefinition>;
+        httpGroups: Record<string, PermissionGroupMeta>;
+        tagGroups: Record<string, PermissionGroupMeta>;
+    };
+    requiredSchemas: Set<string>;
+    openAPISpec: Record<string, any> | null;
+    diagnostics: InspectorDiagnostic[];
 }

package/dist/utils/compute-required-schemas.d.ts

@@ -0,0 +1,4 @@
+import type { FunctionsMeta } from '@pikku/core';
+import type { TypesMap } from '../types-map.js';
+import type { SchemaRef } from '../types.js';
+export declare function computeRequiredSchemas(functionsMeta: FunctionsMeta, typesMap: TypesMap, additionalTypes?: string[], schemaLookup?: Map<string, SchemaRef>): Set<string>;