@pikku/inspector 0.12.2 → 0.12.4

package/dist/add/add-schedule.js

@@ -4,6 +4,7 @@ import { extractFunctionName, makeContextBasedId, } from '../utils/extract-funct
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
 import { resolveMiddleware } from '../utils/middleware.js';
 import { extractWireNames } from '../utils/post-process.js';
+import { resolveAddonName } from '../utils/resolve-addon-package.js';
 import { ErrorCode } from '../error-codes.js';
 export const addSchedule = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
@@ -36,6 +37,9 @@ export const addSchedule = (logger, node, checker, state, options) => {
         if (pikkuFuncId.startsWith('__temp_') && nameValue) {
             pikkuFuncId = makeContextBasedId('scheduler', nameValue);
         }
+        const packageName = ts.isIdentifier(funcInitializer)
+            ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+            : null;
         if (!nameValue || !scheduleValue) {
             return;
         }
@@ -47,6 +51,7 @@ export const addSchedule = (logger, node, checker, state, options) => {
         state.scheduledTasks.files.add(node.getSourceFile().fileName);
         state.scheduledTasks.meta[nameValue] = {
             pikkuFuncId,
+            ...(packageName && { packageName }),
             name: nameValue,
             schedule: scheduleValue,
             summary,

package/dist/add/add-wire-addon.js

@@ -32,6 +32,7 @@ export function addWireAddon(node, state, logger) {
     let name;
     let pkg;
     let rpcEndpoint;
+    let mcp;
     let secretOverrides;
     let variableOverrides;
     for (const prop of firstArg.properties) {
@@ -47,6 +48,11 @@ export function addWireAddon(node, state, logger) {
         else if (key === 'rpcEndpoint' && ts.isStringLiteral(prop.initializer)) {
             rpcEndpoint = prop.initializer.text;
         }
+        else if (key === 'mcp' &&
+            (prop.initializer.kind === ts.SyntaxKind.TrueKeyword ||
+                prop.initializer.kind === ts.SyntaxKind.FalseKeyword)) {
+            mcp = prop.initializer.kind === ts.SyntaxKind.TrueKeyword;
+        }
         else if (key === 'secretOverrides' &&
             ts.isObjectLiteralExpression(prop.initializer)) {
             secretOverrides = parseStringRecord(prop.initializer);
@@ -62,6 +68,7 @@ export function addWireAddon(node, state, logger) {
     state.rpc.wireAddonDeclarations.set(name, {
         package: pkg,
         rpcEndpoint,
+        mcp,
         secretOverrides,
         variableOverrides,
     });

package/dist/add/add-workflow.js

@@ -3,7 +3,7 @@ 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 { getCommonWireMetaData } from '../utils/get-property-value.js';
+import { getCommonWireMetaData, getPropertyValue, } 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)
@@ -182,6 +182,7 @@ export const addWorkflow = (logger, node, checker, state) => {
     let summary;
     let description;
     let errors;
+    let inline;
     if (ts.isObjectLiteralExpression(firstArg)) {
         const metadata = getCommonWireMetaData(firstArg, 'Workflow', workflowName, logger);
         if (metadata.disabled)
@@ -190,6 +191,10 @@ export const addWorkflow = (logger, node, checker, state) => {
         summary = metadata.summary;
         description = metadata.description;
         errors = metadata.errors;
+        const inlineProp = getPropertyValue(firstArg, 'inline');
+        if (inlineProp === true) {
+            inline = true;
+        }
     }
     // Validate that we got a valid function
     if (ts.isObjectLiteralExpression(firstArg) &&
@@ -272,5 +277,6 @@ export const addWorkflow = (logger, node, checker, state) => {
         description,
         errors,
         tags,
+        inline,
     };
 };

package/dist/error-codes.d.ts

@@ -49,6 +49,7 @@ export declare enum ErrorCode {
     MANIFEST_INTEGRITY_ERROR = "PKU865",
     MISSING_MODEL = "PKU145",
     INVALID_MODEL = "PKU146",
+    SCHEMA_AND_WIRING_COLOCATED = "PKU490",
     SERVICES_NOT_DESTRUCTURED = "PKU410",
     WIRES_NOT_DESTRUCTURED = "PKU411",
     WORKFLOW_MULTI_QUEUE_NOT_SUPPORTED = "PKU901"

package/dist/error-codes.js

@@ -58,6 +58,8 @@ export var ErrorCode;
     // Model configuration errors
     ErrorCode["MISSING_MODEL"] = "PKU145";
     ErrorCode["INVALID_MODEL"] = "PKU146";
+    // File structure errors
+    ErrorCode["SCHEMA_AND_WIRING_COLOCATED"] = "PKU490";
     // Optimization diagnostics
     ErrorCode["SERVICES_NOT_DESTRUCTURED"] = "PKU410";
     ErrorCode["WIRES_NOT_DESTRUCTURED"] = "PKU411";

package/dist/index.d.ts

@@ -13,4 +13,5 @@ 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 { resolveFunctionMeta } from './utils/resolve-function-meta.js';
 export type { SerializedWorkflowGraph, SerializedWorkflowGraphs, } from './utils/workflow/graph/index.js';

package/dist/index.js

@@ -7,3 +7,4 @@ export { createEmptyManifest, serializeManifest, } from './utils/contract-hashes
 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';
+export { resolveFunctionMeta } from './utils/resolve-function-meta.js';

package/dist/inspector.js

@@ -4,13 +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, validateAgentModels, validateAgentOverrides, validateSecretOverrides, validateVariableOverrides, computeResolvedIOTypes, computeMiddlewareGroupsMeta, computePermissionsGroupsMeta, computeRequiredSchemas, computeDiagnostics, } from './utils/post-process.js';
+import { aggregateRequiredServices, validateAgentModels, validateAgentOverrides, validateSecretOverrides, validateVariableOverrides, computeResolvedIOTypes, computeMiddlewareGroupsMeta, computePermissionsGroupsMeta, computeRequiredSchemas, computeDiagnostics, validateSchemaWiringSeparation, } from './utils/post-process.js';
 import { generateOpenAPISpec } from './utils/serialize-openapi-json.js';
 import { pikkuState } from '@pikku/core/internal';
 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 { loadAddonFunctionsMeta, loadAddonSchemas, } from './utils/load-addon-functions-meta.js';
 import { computeContractHashes, extractContractsFromMeta, updateManifest, createEmptyManifest, validateContracts, } from './utils/contract-hashes.js';
 /**
  * Creates an initial/empty inspector state with all required properties initialized
@@ -37,6 +38,7 @@ export function getInitialInspectorState(rootDir) {
             typesMap: new TypesMap(),
             meta: {},
             files: new Map(),
+            approvalDescriptions: {},
         },
         http: {
             metaInputTypes: new Map(),
@@ -171,11 +173,12 @@ export function getInitialInspectorState(rootDir) {
         requiredSchemas: new Set(),
         openAPISpec: null,
         diagnostics: [],
+        addonFunctions: {},
+        program: null,
     };
 }
 export const inspect = async (logger, routeFiles, options = {}) => {
-    const startProgram = performance.now();
-    const program = ts.createProgram(routeFiles, {
+    const compilerOptions = {
         target: ts.ScriptTarget.ESNext,
         module: ts.ModuleKind.Node16,
         skipLibCheck: true,
@@ -184,8 +187,11 @@ export const inspect = async (logger, routeFiles, options = {}) => {
         types: [],
         allowJs: false,
         checkJs: false,
-    });
-    logger.debug(`Created program in ${(performance.now() - startProgram).toFixed(2)}ms`);
+    };
+    const startProgram = performance.now();
+    const program = ts.createProgram(routeFiles, compilerOptions, undefined, // host
+    options.oldProgram);
+    logger.debug(`Created program in ${(performance.now() - startProgram).toFixed(0)}ms (${routeFiles.length} files${options.oldProgram ? ', incremental' : ''})`);
     const startChecker = performance.now();
     const checker = program.getTypeChecker();
     logger.debug(`Got type checker in ${(performance.now() - startChecker).toFixed(2)}ms`);
@@ -204,20 +210,26 @@ export const inspect = async (logger, routeFiles, options = {}) => {
     for (const sourceFile of sourceFiles) {
         ts.forEachChild(sourceFile, (child) => visitSetup(logger, checker, child, state, options));
     }
-    logger.debug(`Visit setup phase completed in ${(performance.now() - startSetup).toFixed(2)}ms`);
+    logger.debug(`Visit setup phase completed in ${(performance.now() - startSetup).toFixed(0)}ms`);
+    // Load addon function metadata so wirings can reference addon functions
+    await loadAddonFunctionsMeta(logger, state);
     if (!options.setupOnly) {
         // Second sweep: add all transports
         const startRoutes = performance.now();
         for (const sourceFile of sourceFiles) {
             ts.forEachChild(sourceFile, (child) => visitRoutes(logger, checker, child, state, options));
         }
-        logger.debug(`Visit routes phase completed in ${(performance.now() - startRoutes).toFixed(2)}ms`);
+        logger.debug(`Visit routes phase completed in ${(performance.now() - startRoutes).toFixed(0)}ms`);
         resolveLatestVersions(state, logger);
         if (options.schemaConfig) {
+            const startSchemas = performance.now();
             state.schemas = await generateAllSchemas(logger, options.schemaConfig, state);
+            logger.debug(`generateAllSchemas took ${(performance.now() - startSchemas).toFixed(0)}ms`);
             computeContractHashes(state.schemas, state.functions.typesMap, state.functions.meta);
             computeRequiredSchemas(state, options);
         }
+        // Re-load addon schemas (generateAllSchemas replaces state.schemas)
+        await loadAddonSchemas(logger, state);
         state.manifest.initial = options.manifest ?? null;
         const contracts = extractContractsFromMeta(state.functions.meta);
         const baseManifest = state.manifest.initial ?? createEmptyManifest();
@@ -241,6 +253,7 @@ export const inspect = async (logger, routeFiles, options = {}) => {
         computeMiddlewareGroupsMeta(state);
         computePermissionsGroupsMeta(state);
         computeDiagnostics(state);
+        validateSchemaWiringSeparation(logger, state);
         if (options.openAPI) {
             state.openAPISpec = await generateOpenAPISpec(logger, state.functions.meta, state.http.meta, state.schemas, options.openAPI.additionalInfo, pikkuState(null, 'misc', 'errors'));
         }
@@ -249,5 +262,6 @@ export const inspect = async (logger, routeFiles, options = {}) => {
         validateSecretOverrides(logger, state);
         validateVariableOverrides(logger, state);
     }
+    state.program = program;
     return state;
 };

package/dist/types.d.ts

@@ -73,6 +73,7 @@ export interface InspectorFunctionState {
         path: string;
         exportedName: string;
     }>;
+    approvalDescriptions: Record<string, InspectorApprovalDescriptionDefinition>;
 }
 export interface InspectorChannelState {
     meta: ChannelsMeta;
@@ -108,6 +109,13 @@ export interface InspectorChannelMiddlewareState {
 export interface InspectorAIMiddlewareState {
     definitions: Record<string, InspectorMiddlewareDefinition>;
 }
+export interface InspectorApprovalDescriptionDefinition {
+    services: FunctionServicesMeta;
+    wires?: FunctionWiresMeta;
+    sourceFile: string;
+    position: number;
+    exportedName: string | null;
+}
 export interface InspectorPermissionDefinition {
     services: FunctionServicesMeta;
     wires?: FunctionWiresMeta;
@@ -185,6 +193,7 @@ export type InspectorOptions = Partial<{
     tags: string[];
     manifest: VersionManifest;
     modelConfig: InspectorModelConfig;
+    oldProgram: ts.Program | undefined;
 }>;
 export interface InspectorLogger {
     info: (message: string) => void;
@@ -309,6 +318,7 @@ export interface InspectorState {
         wireAddonDeclarations: Map<string, {
             package: string;
             rpcEndpoint?: string;
+            mcp?: boolean;
             secretOverrides?: Record<string, string>;
             variableOverrides?: Record<string, string>;
         }>;
@@ -383,4 +393,6 @@ export interface InspectorState {
     requiredSchemas: Set<string>;
     openAPISpec: Record<string, any> | null;
     diagnostics: InspectorDiagnostic[];
+    addonFunctions: Record<string, FunctionsMeta>;
+    program: ts.Program | null;
 }

package/dist/utils/custom-types-generator.js

@@ -9,6 +9,7 @@ export function sanitizeTypeName(name) {
 }
 export function generateCustomTypes(typesMap, requiredTypes) {
     const typeDeclarations = Array.from(typesMap.customTypes.entries())
+        .sort(([a], [b]) => a.localeCompare(b))
         .filter(([_name, { type }]) => {
         const hasUndefinedGeneric = /\b(Name|In|Out|Key)\b/.test(type) && /\[.*\]/.test(type);
         return !hasUndefinedGeneric;

package/dist/utils/load-addon-functions-meta.d.ts

@@ -0,0 +1,12 @@
+import type { InspectorState, InspectorLogger } from '../types.js';
+/**
+ * After the setup sweep discovers wireAddon() declarations, load each addon
+ * package's function metadata so that wiring handlers (channels, HTTP routes,
+ * schedules, etc.) can look up addon function types during the routes sweep.
+ */
+export declare function loadAddonFunctionsMeta(logger: InspectorLogger, state: InspectorState): Promise<void>;
+/**
+ * Load addon schemas into state.schemas. Called after generateAllSchemas
+ * to ensure addon schemas aren't overwritten.
+ */
+export declare function loadAddonSchemas(logger: InspectorLogger, state: InspectorState): Promise<void>;

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

@@ -0,0 +1,76 @@
+import { readFile, readdir } from 'fs/promises';
+import { createRequire } from 'module';
+import { join, dirname } from 'path';
+/**
+ * After the setup sweep discovers wireAddon() declarations, load each addon
+ * package's function metadata so that wiring handlers (channels, HTTP routes,
+ * schedules, etc.) can look up addon function types during the routes sweep.
+ */
+export async function loadAddonFunctionsMeta(logger, state) {
+    const { wireAddonDeclarations } = state.rpc;
+    if (wireAddonDeclarations.size === 0)
+        return;
+    const require = createRequire(join(state.rootDir, 'package.json'));
+    for (const [namespace, decl] of wireAddonDeclarations) {
+        try {
+            const metaPath = require.resolve(`${decl.package}/.pikku/function/pikku-functions-meta.gen.json`);
+            const raw = await readFile(metaPath, 'utf-8');
+            const meta = JSON.parse(raw);
+            state.addonFunctions[namespace] = meta;
+            logger.debug(`Loaded ${Object.keys(meta).length} addon functions for '${namespace}' from ${decl.package}`);
+            // If wireAddon has mcp: true, expose addon functions with mcp: true as MCP tools
+            if (decl.mcp) {
+                for (const [funcName, funcMeta] of Object.entries(meta)) {
+                    if (funcMeta.mcp) {
+                        const toolName = `${namespace}:${funcName}`;
+                        state.mcpEndpoints.toolsMeta[toolName] = {
+                            pikkuFuncId: `${namespace}:${funcName}`,
+                            name: toolName,
+                            description: funcMeta.description || funcMeta.title || funcName,
+                            inputSchema: funcMeta.inputSchemaName ?? null,
+                            outputSchema: funcMeta.outputSchemaName ?? null,
+                            tags: funcMeta.tags,
+                        };
+                    }
+                }
+            }
+        }
+        catch (error) {
+            logger.warn(`Failed to load addon function metadata for '${namespace}' (${decl.package}): ${error.message}`);
+        }
+    }
+}
+/**
+ * Load addon schemas into state.schemas. Called after generateAllSchemas
+ * to ensure addon schemas aren't overwritten.
+ */
+export async function loadAddonSchemas(logger, state) {
+    const { wireAddonDeclarations } = state.rpc;
+    if (wireAddonDeclarations.size === 0)
+        return;
+    const require = createRequire(join(state.rootDir, 'package.json'));
+    for (const [namespace, decl] of wireAddonDeclarations) {
+        try {
+            const metaPath = require.resolve(`${decl.package}/.pikku/function/pikku-functions-meta.gen.json`);
+            const schemasDir = join(dirname(metaPath), '..', 'schemas', 'schemas');
+            try {
+                const schemaFiles = await readdir(schemasDir);
+                for (const file of schemaFiles) {
+                    if (!file.endsWith('.schema.json'))
+                        continue;
+                    const schemaName = file.replace('.schema.json', '');
+                    if (!state.schemas[schemaName]) {
+                        const schemaRaw = await readFile(join(schemasDir, file), 'utf-8');
+                        state.schemas[schemaName] = JSON.parse(schemaRaw);
+                    }
+                }
+            }
+            catch {
+                // No schemas directory — that's fine
+            }
+        }
+        catch (error) {
+            logger.warn(`Failed to load addon schemas for '${namespace}' (${decl.package}): ${error.message}`);
+        }
+    }
+}

package/dist/utils/post-process.d.ts

@@ -22,4 +22,13 @@ export declare function computePermissionsGroupsMeta(state: InspectorState): voi
 export declare function computeRequiredSchemas(state: InspectorState, options: InspectorOptions): void;
 export declare function validateAgentModels(logger: InspectorLogger, state: InspectorState | Omit<InspectorState, 'typesLookup'>, modelConfig?: InspectorModelConfig): void;
 export declare function validateAgentOverrides(logger: InspectorLogger, state: InspectorState | Omit<InspectorState, 'typesLookup'>, modelConfig?: InspectorModelConfig): void;
+/**
+ * Validates that Zod schemas and wiring side-effects (wireHTTPRoutes,
+ * addPermission, addHTTPMiddleware, etc.) do not coexist in the same file.
+ *
+ * The CLI uses tsImport to extract Zod schemas at runtime, which executes
+ * all top-level code in the file. Wiring calls crash during this process
+ * because the pikku state metadata doesn't exist in the CLI context.
+ */
+export declare function validateSchemaWiringSeparation(logger: InspectorLogger, state: InspectorState): void;
 export declare function computeDiagnostics(state: InspectorState): void;

package/dist/utils/post-process.js

@@ -217,6 +217,32 @@ export function computeResolvedIOTypes(state) {
             }
         }
         state.resolvedIOTypes[pikkuFuncId] = { inputType, outputType };
+        if (meta.inputSchemaName && inputType !== 'null') {
+            meta.inputSchemaName = inputType;
+        }
+        if (meta.outputSchemaName && outputType !== 'null') {
+            meta.outputSchemaName = outputType;
+        }
+        if (meta.inputs) {
+            meta.inputs = meta.inputs.map((name) => {
+                try {
+                    return functions.typesMap.getTypeMeta(name).uniqueName;
+                }
+                catch {
+                    return name;
+                }
+            });
+        }
+        if (meta.outputs) {
+            meta.outputs = meta.outputs.map((name) => {
+                try {
+                    return functions.typesMap.getTypeMeta(name).uniqueName;
+                }
+                catch {
+                    return name;
+                }
+            });
+        }
     }
 }
 const serializeGroupMap = (groupMap) => {
@@ -352,6 +378,52 @@ export function validateAgentOverrides(logger, state, modelConfig) {
         }
     }
 }
+/**
+ * Validates that Zod schemas and wiring side-effects (wireHTTPRoutes,
+ * addPermission, addHTTPMiddleware, etc.) do not coexist in the same file.
+ *
+ * The CLI uses tsImport to extract Zod schemas at runtime, which executes
+ * all top-level code in the file. Wiring calls crash during this process
+ * because the pikku state metadata doesn't exist in the CLI context.
+ */
+export function validateSchemaWiringSeparation(logger, state) {
+    // Collect files that contain schemas
+    const schemaFiles = new Set();
+    for (const ref of state.schemaLookup.values()) {
+        schemaFiles.add(ref.sourceFile);
+    }
+    // Collect files that contain wiring side-effects
+    const wiringFiles = new Set();
+    // HTTP route wirings
+    for (const file of state.http.files) {
+        wiringFiles.add(file);
+    }
+    // Permission wirings (addPermission calls)
+    for (const meta of state.permissions.tagPermissions.values()) {
+        wiringFiles.add(meta.sourceFile);
+    }
+    for (const meta of state.http.routePermissions.values()) {
+        wiringFiles.add(meta.sourceFile);
+    }
+    // Middleware wirings (addHTTPMiddleware calls)
+    for (const meta of state.http.routeMiddleware.values()) {
+        wiringFiles.add(meta.sourceFile);
+    }
+    for (const meta of state.middleware.tagMiddleware.values()) {
+        wiringFiles.add(meta.sourceFile);
+    }
+    // Check for overlap
+    for (const file of schemaFiles) {
+        if (wiringFiles.has(file)) {
+            const schemas = Array.from(state.schemaLookup.entries())
+                .filter(([, ref]) => ref.sourceFile === file)
+                .map(([name]) => name);
+            logger.critical(ErrorCode.SCHEMA_AND_WIRING_COLOCATED, `File '${file}' contains both Zod schemas (${schemas.join(', ')}) and wiring calls (wireHTTPRoutes, addPermission, etc.). ` +
+                `These must be in separate files because the CLI imports schema files at runtime, which triggers wiring side-effects that crash without server context. ` +
+                `Move the route/wiring definitions to a dedicated wiring file.`);
+        }
+    }
+}
 export function computeDiagnostics(state) {
     const diagnostics = [];
     for (const [id, meta] of Object.entries(state.functions.meta)) {

package/dist/utils/resolve-function-meta.d.ts

@@ -0,0 +1,11 @@
+import type { FunctionMeta, FunctionsMeta } from '@pikku/core';
+/**
+ * Look up function metadata by pikkuFuncId, checking both local functions
+ * and addon functions. Addon functions use namespaced IDs like 'namespace:funcName'.
+ */
+export declare function resolveFunctionMeta(state: {
+    functions: {
+        meta: FunctionsMeta;
+    };
+    addonFunctions: Record<string, FunctionsMeta>;
+}, pikkuFuncId: string): FunctionMeta | undefined;

package/dist/utils/resolve-function-meta.js

@@ -0,0 +1,17 @@
+/**
+ * Look up function metadata by pikkuFuncId, checking both local functions
+ * and addon functions. Addon functions use namespaced IDs like 'namespace:funcName'.
+ */
+export function resolveFunctionMeta(state, pikkuFuncId) {
+    // Check local functions first
+    const local = state.functions.meta[pikkuFuncId];
+    if (local)
+        return local;
+    // Check addon functions (namespaced like 'swaggerPetstore:addPet')
+    const colonIndex = pikkuFuncId.indexOf(':');
+    if (colonIndex === -1)
+        return undefined;
+    const namespace = pikkuFuncId.substring(0, colonIndex);
+    const funcName = pikkuFuncId.substring(colonIndex + 1);
+    return state.addonFunctions[namespace]?.[funcName];
+}

package/dist/utils/schema-generator.js

@@ -46,14 +46,25 @@ function primitiveTypeToSchema(typeStr) {
     }
     return null;
 }
+// Cached state for schema program reuse across inspect() calls
+let cachedSchemaProgram;
+let cachedParsedConfig;
+let cachedTsconfigPath;
+let cachedCustomTypesContent;
+let cachedTSSchemas;
 function createProgramWithVirtualFile(tsconfig, virtualFilePath, virtualFileContent) {
     const configPath = resolve(tsconfig);
-    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-    const basePath = dirname(configPath);
-    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, basePath);
+    // Cache the parsed tsconfig — it doesn't change between runs
+    if (!cachedParsedConfig || cachedTsconfigPath !== configPath) {
+        const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+        const basePath = dirname(configPath);
+        cachedParsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, basePath);
+        cachedTsconfigPath = configPath;
+        cachedSchemaProgram = undefined;
+    }
     const resolvedVirtualPath = resolve(virtualFilePath);
-    const fileNames = [...parsedConfig.fileNames, resolvedVirtualPath];
-    const defaultHost = ts.createCompilerHost(parsedConfig.options);
+    const fileNames = [...cachedParsedConfig.fileNames, resolvedVirtualPath];
+    const defaultHost = ts.createCompilerHost(cachedParsedConfig.options);
     const customHost = {
         ...defaultHost,
         getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
@@ -73,7 +84,10 @@ function createProgramWithVirtualFile(tsconfig, virtualFilePath, virtualFileCont
             return defaultHost.readFile(fileName);
         },
     };
-    return ts.createProgram(fileNames, parsedConfig.options, customHost);
+    const program = ts.createProgram(fileNames, cachedParsedConfig.options, customHost, cachedSchemaProgram // reuse previous program for incremental compilation
+    );
+    cachedSchemaProgram = program;
+    return program;
 }
 function generateTSSchemas(logger, tsconfig, customTypesContent, typesMap, functionMeta, httpWiringsMeta, additionalTypes, additionalProperties = false, schemaLookup) {
     const schemasSet = new Set(typesMap.customTypes.keys());
@@ -204,6 +218,12 @@ export async function generateAllSchemas(logger, config, state) {
     const zodSchemas = await generateZodSchemas(logger, state.schemaLookup, state.functions.typesMap);
     const requiredTypes = new Set();
     const customTypesContent = generateCustomTypes(state.functions.typesMap, requiredTypes);
+    if (cachedTSSchemas && cachedCustomTypesContent === customTypesContent) {
+        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);
+    cachedCustomTypesContent = customTypesContent;
+    cachedTSSchemas = tsSchemas;
     return { ...tsSchemas, ...zodSchemas };
 }

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

@@ -100,6 +100,7 @@ export interface SerializableInspectorState {
             path: string;
             exportedName: string;
         }]>;
+        approvalDescriptions: InspectorState['functions']['approvalDescriptions'];
     };
     http: {
         metaInputTypes: Array<[
@@ -253,6 +254,7 @@ export interface SerializableInspectorState {
     requiredSchemas: string[];
     openAPISpec: Record<string, any> | null;
     diagnostics: InspectorDiagnostic[];
+    addonFunctions: InspectorState['addonFunctions'];
 }
 /**
  * Serializes InspectorState to a JSON-compatible format

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

@@ -32,6 +32,7 @@ export function serializeInspectorState(state) {
             typesMap: serializeTypesMap(state.functions.typesMap),
             meta: state.functions.meta,
             files: Array.from(state.functions.files.entries()),
+            approvalDescriptions: state.functions.approvalDescriptions,
         },
         http: {
             metaInputTypes: Array.from(state.http.metaInputTypes.entries()),
@@ -137,6 +138,7 @@ export function serializeInspectorState(state) {
         requiredSchemas: Array.from(state.requiredSchemas),
         openAPISpec: state.openAPISpec,
         diagnostics: state.diagnostics,
+        addonFunctions: state.addonFunctions,
     };
 }
 /**
@@ -173,6 +175,7 @@ export function deserializeInspectorState(data) {
             typesMap: deserializeTypesMap(data.functions.typesMap),
             meta: data.functions.meta,
             files: new Map(data.functions.files),
+            approvalDescriptions: data.functions.approvalDescriptions || {},
         },
         http: {
             metaInputTypes: new Map(data.http.metaInputTypes),
@@ -288,5 +291,7 @@ export function deserializeInspectorState(data) {
         requiredSchemas: new Set(data.requiredSchemas || []),
         openAPISpec: data.openAPISpec || null,
         diagnostics: data.diagnostics || [],
+        addonFunctions: data.addonFunctions || {},
+        program: null,
     };
 }

package/dist/utils/serialize-mcp-json.js

@@ -1,6 +1,7 @@
+import { resolveFunctionMeta } from './resolve-function-meta.js';
 export const serializeMCPJson = (logger, state) => {
     const { mcpEndpoints, functions, schemas } = state;
-    const { meta: functionsMeta, typesMap } = functions;
+    const { typesMap } = functions;
     const { resourcesMeta, toolsMeta, promptsMeta } = mcpEndpoints;
     const tools = [];
     const resources = [];
@@ -19,9 +20,14 @@ export const serializeMCPJson = (logger, state) => {
             ].includes(typeName)) {
             return undefined;
         }
-        const uniqueName = typesMap.getUniqueName(typeName);
-        if (!uniqueName) {
-            return undefined;
+        // Try local typesMap first, fall back to direct schema lookup (for addon types)
+        let uniqueName;
+        try {
+            uniqueName = typesMap.getUniqueName(typeName);
+        }
+        catch {
+            // Type not in local typesMap — try direct schema lookup (addon schemas)
+            uniqueName = typeName;
         }
         const schema = schemas[uniqueName];
         if (!schema) {
@@ -31,7 +37,7 @@ export const serializeMCPJson = (logger, state) => {
         return schema;
     };
     for (const [name, endpointMeta] of Object.entries(resourcesMeta)) {
-        const functionMeta = functionsMeta[endpointMeta.pikkuFuncId];
+        const functionMeta = resolveFunctionMeta(state, endpointMeta.pikkuFuncId);
         if (!functionMeta) {
             logger.warn(`Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping resource ${name}.`);
             continue;
@@ -50,7 +56,7 @@ export const serializeMCPJson = (logger, state) => {
         });
     }
     for (const [name, endpointMeta] of Object.entries(toolsMeta)) {
-        const functionMeta = functionsMeta[endpointMeta.pikkuFuncId];
+        const functionMeta = resolveFunctionMeta(state, endpointMeta.pikkuFuncId);
         if (!functionMeta) {
             logger.warn(`Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping tool ${name}.`);
             continue;
@@ -68,7 +74,7 @@ export const serializeMCPJson = (logger, state) => {
         });
     }
     for (const [name, endpointMeta] of Object.entries(promptsMeta)) {
-        const functionMeta = functionsMeta[endpointMeta.pikkuFuncId];
+        const functionMeta = resolveFunctionMeta(state, endpointMeta.pikkuFuncId);
         if (!functionMeta) {
             logger.warn(`Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping prompt ${name}.`);
             continue;