@pikku/inspector 0.11.1 → 0.12.0

package/dist/utils/schema-generator.js

@@ -0,0 +1,209 @@
+import * as ts from 'typescript';
+import { dirname, join, resolve } from 'path';
+import { createGenerator, RootlessError } from 'ts-json-schema-generator';
+import { tsImport } from 'tsx/esm/api';
+import * as z from 'zod';
+import { zodToTs, createAuxiliaryTypeStore } from 'zod-to-ts';
+import { ErrorCode } from '../error-codes.js';
+import { generateCustomTypes } from './custom-types-generator.js';
+const PRIMITIVE_TYPES = new Set([
+    'boolean',
+    'string',
+    'number',
+    'null',
+    'undefined',
+    'void',
+    'any',
+    'unknown',
+    'never',
+]);
+function primitiveTypeToSchema(typeStr) {
+    const normalized = typeStr.trim();
+    if (normalized === 'void' ||
+        normalized === 'undefined' ||
+        normalized === 'never') {
+        return null;
+    }
+    if (normalized === 'boolean' ||
+        normalized === 'false | true' ||
+        normalized === 'true | false') {
+        return { type: 'boolean' };
+    }
+    if (normalized === 'true') {
+        return { const: true };
+    }
+    if (normalized === 'false') {
+        return { const: false };
+    }
+    if (normalized === 'string') {
+        return { type: 'string' };
+    }
+    if (normalized === 'number') {
+        return { type: 'number' };
+    }
+    if (normalized === 'null') {
+        return { type: 'null' };
+    }
+    return null;
+}
+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);
+    const resolvedVirtualPath = resolve(virtualFilePath);
+    const fileNames = [...parsedConfig.fileNames, resolvedVirtualPath];
+    const defaultHost = ts.createCompilerHost(parsedConfig.options);
+    const customHost = {
+        ...defaultHost,
+        getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
+            if (resolve(fileName) === resolvedVirtualPath) {
+                return ts.createSourceFile(fileName, virtualFileContent, languageVersionOrOptions);
+            }
+            return defaultHost.getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+        },
+        fileExists(fileName) {
+            if (resolve(fileName) === resolvedVirtualPath)
+                return true;
+            return defaultHost.fileExists(fileName);
+        },
+        readFile(fileName) {
+            if (resolve(fileName) === resolvedVirtualPath)
+                return virtualFileContent;
+            return defaultHost.readFile(fileName);
+        },
+    };
+    return ts.createProgram(fileNames, parsedConfig.options, customHost);
+}
+function generateTSSchemas(logger, tsconfig, customTypesContent, typesMap, functionMeta, httpWiringsMeta, additionalTypes, additionalProperties = false, schemaLookup) {
+    const schemasSet = new Set(typesMap.customTypes.keys());
+    for (const { inputs, outputs } of Object.values(functionMeta)) {
+        const types = [...(inputs || []), ...(outputs || [])];
+        for (const type of types) {
+            try {
+                const uniqueName = typesMap.getUniqueName(type);
+                if (uniqueName) {
+                    schemasSet.add(uniqueName);
+                }
+            }
+            catch {
+                // Skip types not in typesMap (e.g., inline types in generated workflow workers)
+            }
+        }
+    }
+    for (const wiringRoutes of Object.values(httpWiringsMeta)) {
+        for (const { inputTypes } of Object.values(wiringRoutes)) {
+            if (inputTypes?.body) {
+                schemasSet.add(inputTypes.body);
+            }
+            if (inputTypes?.query) {
+                schemasSet.add(inputTypes.query);
+            }
+            if (inputTypes?.params) {
+                schemasSet.add(inputTypes.params);
+            }
+        }
+    }
+    if (additionalTypes) {
+        for (const type of additionalTypes) {
+            schemasSet.add(type);
+        }
+    }
+    const virtualFilePath = join(dirname(resolve(tsconfig)), '__pikku_virtual_types__.ts');
+    const program = createProgramWithVirtualFile(tsconfig, virtualFilePath, customTypesContent);
+    const generator = createGenerator({
+        tsProgram: program,
+        skipTypeCheck: true,
+        topRef: false,
+        discriminatorType: 'open-api',
+        expose: 'export',
+        jsDoc: 'extended',
+        sortProps: true,
+        strictTuples: false,
+        encodeRefs: false,
+        additionalProperties,
+    });
+    const schemas = {};
+    schemasSet.forEach((schema) => {
+        if (PRIMITIVE_TYPES.has(schema)) {
+            return;
+        }
+        if (schemaLookup?.has(schema)) {
+            return;
+        }
+        try {
+            schemas[schema] = generator.createSchema(schema);
+        }
+        catch (e) {
+            if (e instanceof RootlessError) {
+                const customType = typesMap.customTypes.get(schema);
+                if (customType) {
+                    const primitiveSchema = primitiveTypeToSchema(customType.type);
+                    if (primitiveSchema) {
+                        schemas[schema] = primitiveSchema;
+                    }
+                }
+                return;
+            }
+            const customType = typesMap.customTypes.get(schema);
+            logger.error(`[${ErrorCode.SCHEMA_GENERATION_ERROR}] Error generating schema: ${schema}. Message: ${e.message}. Type info: ${customType ? `type=${customType.type}` : 'not in typesMap'}`);
+        }
+    });
+    return schemas;
+}
+async function generateZodSchemas(logger, schemaLookup, typesMap) {
+    const schemas = {};
+    const auxiliaryTypeStore = createAuxiliaryTypeStore();
+    const printer = ts.createPrinter();
+    const fakeSourceFile = ts.createSourceFile('zod-types.ts', '', ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
+    for (const [schemaName, ref] of schemaLookup.entries()) {
+        if (ref.vendor && ref.vendor !== 'zod') {
+            throw new Error(`Schema '${schemaName}' uses ${ref.vendor} which is not yet supported for JSON Schema generation. ` +
+                `Currently only Zod schemas can be converted to JSON Schema. ` +
+                `Please use Zod or contribute support for ${ref.vendor}.`);
+        }
+        try {
+            const module = await tsImport(ref.sourceFile, import.meta.url);
+            const zodSchema = module[ref.variableName];
+            if (!zodSchema) {
+                logger.warn(`Could not find exported schema '${ref.variableName}' in ${ref.sourceFile} for ${schemaName}. Available exports: ${Object.keys(module).join(', ')}`);
+                continue;
+            }
+            const schema = z.toJSONSchema(zodSchema, {
+                unrepresentable: 'any',
+                override: ({ zodSchema, jsonSchema }) => {
+                    if (zodSchema._zod?.def?.type === 'date') {
+                        ;
+                        jsonSchema.type = 'string';
+                        jsonSchema.format = 'date-time';
+                    }
+                },
+            });
+            if (schema.required && schema.properties) {
+                schema.required = schema.required.filter((fieldName) => {
+                    const prop = schema.properties[fieldName];
+                    return prop && prop.default === undefined;
+                });
+                if (schema.required.length === 0) {
+                    delete schema.required;
+                }
+            }
+            schemas[schemaName] = schema;
+            const { node: tsType } = zodToTs(zodSchema, { auxiliaryTypeStore });
+            const typeText = printer.printNode(ts.EmitHint.Unspecified, tsType, fakeSourceFile);
+            typesMap.addCustomType(schemaName, typeText, []);
+            logger.debug(`• Generated schema from Zod: ${schemaName}`);
+        }
+        catch (e) {
+            logger.warn(`Could not convert Zod schema '${schemaName}': ${e instanceof Error ? e.message : e}`);
+        }
+    }
+    return schemas;
+}
+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);
+    const tsSchemas = generateTSSchemas(logger, config.tsconfig, customTypesContent, state.functions.typesMap, state.functions.meta, state.http.meta, config.schemasFromTypes, config.schema?.additionalProperties, state.schemaLookup);
+    return { ...tsSchemas, ...zodSchemas };
+}

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

@@ -1,4 +1,5 @@
-import { InspectorState } from '../types.js';
+import { JSONValue } from '@pikku/core';
+import { InspectorDiagnostic, InspectorState } from '../types.js';
 /**
  * Serializable version of InspectorState that can be saved to JSON
  * Omits typesLookup (contains non-serializable ts.Type objects) and converts Maps/Sets to arrays
@@ -74,6 +75,15 @@ export interface SerializableInspectorState {
             }[]
         ]>
     ]>;
+    schemaLookup: Array<[
+        string,
+        {
+            variableName: string;
+            sourceFile: string;
+            vendor?: 'zod' | 'valibot' | 'arktype' | 'effect' | 'unknown';
+        }
+    ]>;
+    schemas: Record<string, JSONValue>;
     functions: {
         typesMap: {
             map: Array<[string, {
@@ -115,6 +125,11 @@ export interface SerializableInspectorState {
         files: string[];
         meta: InspectorState['channels']['meta'];
     };
+    triggers: {
+        meta: InspectorState['triggers']['meta'];
+        sourceMeta: InspectorState['triggers']['sourceMeta'];
+        files: string[];
+    };
     scheduledTasks: {
         meta: InspectorState['scheduledTasks']['meta'];
         files: string[];
@@ -129,6 +144,12 @@ export interface SerializableInspectorState {
             path: string;
             exportedName: string;
         }]>;
+        graphMeta: InspectorState['workflows']['graphMeta'];
+        graphFiles: Array<[string, {
+            path: string;
+            exportedName: string;
+        }]>;
+        invokedWorkflows: string[];
     };
     rpc: {
         internalMeta: InspectorState['rpc']['internalMeta'];
@@ -142,6 +163,7 @@ export interface SerializableInspectorState {
             exportedName: string;
         }]>;
         invokedFunctions: string[];
+        usedExternalPackages: string[];
     };
     mcpEndpoints: {
         resourcesMeta: InspectorState['mcpEndpoints']['resourcesMeta'];
@@ -149,19 +171,52 @@ export interface SerializableInspectorState {
         promptsMeta: InspectorState['mcpEndpoints']['promptsMeta'];
         files: string[];
     };
+    agents: {
+        agentsMeta: InspectorState['agents']['agentsMeta'];
+        files: [string, {
+            path: string;
+            exportedName: string;
+        }][];
+    };
     cli: {
         meta: InspectorState['cli']['meta'];
         files: string[];
     };
+    nodes: {
+        meta: InspectorState['nodes']['meta'];
+        files: string[];
+    };
+    secrets: {
+        definitions: InspectorState['secrets']['definitions'];
+        files: string[];
+    };
+    variables: {
+        definitions: InspectorState['variables']['definitions'];
+        files: string[];
+    };
+    manifest: InspectorState['manifest'];
     middleware: {
-        meta: InspectorState['middleware']['meta'];
+        definitions: InspectorState['middleware']['definitions'];
+        instances: InspectorState['middleware']['instances'];
         tagMiddleware: Array<[
             string,
             InspectorState['middleware']['tagMiddleware'] extends Map<string, infer V> ? V : never
         ]>;
     };
+    channelMiddleware: {
+        definitions: InspectorState['channelMiddleware']['definitions'];
+        instances: InspectorState['channelMiddleware']['instances'];
+        tagMiddleware: Array<[
+            string,
+            InspectorState['channelMiddleware']['tagMiddleware'] extends Map<string, infer V> ? V : never
+        ]>;
+    };
+    aiMiddleware: {
+        definitions: InspectorState['aiMiddleware']['definitions'];
+    };
     permissions: {
-        meta: InspectorState['permissions']['meta'];
+        definitions: InspectorState['permissions']['definitions'];
+        instances: InspectorState['permissions']['instances'];
         tagPermissions: Array<[
             string,
             InspectorState['permissions']['tagPermissions'] extends Map<string, infer V> ? V : never
@@ -175,16 +230,15 @@ export interface SerializableInspectorState {
         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: InspectorState['middlewareGroupsMeta'];
+    permissionsGroupsMeta: InspectorState['permissionsGroupsMeta'];
+    requiredSchemas: string[];
+    openAPISpec: Record<string, any> | null;
+    diagnostics: InspectorDiagnostic[];
 }
 /**
  * Serializes InspectorState to a JSON-compatible format
@@ -195,4 +249,10 @@ 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' | 'schemaLookup'> & {
+    schemaLookup: Map<string, {
+        variableName: string;
+        sourceFile: string;
+        vendor?: 'zod' | 'valibot' | 'arktype' | 'effect' | 'unknown';
+    }>;
+};

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

@@ -26,6 +26,8 @@ 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())]),
+        schemaLookup: Array.from(state.schemaLookup.entries()),
+        schemas: state.schemas,
         functions: {
             typesMap: serializeTypesMap(state.functions.typesMap),
             meta: state.functions.meta,
@@ -42,6 +44,11 @@ export function serializeInspectorState(state) {
             files: Array.from(state.channels.files),
             meta: state.channels.meta,
         },
+        triggers: {
+            meta: state.triggers.meta,
+            sourceMeta: state.triggers.sourceMeta,
+            files: Array.from(state.triggers.files),
+        },
         scheduledTasks: {
             meta: state.scheduledTasks.meta,
             files: Array.from(state.scheduledTasks.files),
@@ -53,6 +60,9 @@ 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()),
+            invokedWorkflows: Array.from(state.workflows.invokedWorkflows),
         },
         rpc: {
             internalMeta: state.rpc.internalMeta,
@@ -60,6 +70,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,
@@ -67,16 +78,43 @@ export function serializeInspectorState(state) {
             promptsMeta: state.mcpEndpoints.promptsMeta,
             files: Array.from(state.mcpEndpoints.files),
         },
+        agents: {
+            agentsMeta: state.agents?.agentsMeta ?? {},
+            files: Array.from(state.agents?.files?.entries() ?? []),
+        },
         cli: {
             meta: state.cli.meta,
             files: Array.from(state.cli.files),
         },
+        nodes: {
+            meta: state.nodes.meta,
+            files: Array.from(state.nodes.files),
+        },
+        secrets: {
+            definitions: state.secrets.definitions,
+            files: Array.from(state.secrets.files),
+        },
+        variables: {
+            definitions: state.variables.definitions,
+            files: Array.from(state.variables.files),
+        },
+        manifest: state.manifest,
         middleware: {
-            meta: state.middleware.meta,
+            definitions: state.middleware.definitions,
+            instances: state.middleware.instances,
             tagMiddleware: Array.from(state.middleware.tagMiddleware.entries()),
         },
+        channelMiddleware: {
+            definitions: state.channelMiddleware.definitions,
+            instances: state.channelMiddleware.instances,
+            tagMiddleware: Array.from(state.channelMiddleware.tagMiddleware.entries()),
+        },
+        aiMiddleware: {
+            definitions: state.aiMiddleware.definitions,
+        },
         permissions: {
-            meta: state.permissions.meta,
+            definitions: state.permissions.definitions,
+            instances: state.permissions.instances,
             tagPermissions: Array.from(state.permissions.tagPermissions.entries()),
         },
         serviceAggregation: {
@@ -87,7 +125,12 @@ export function serializeInspectorState(state) {
             allSingletonServices: state.serviceAggregation.allSingletonServices,
             allWireServices: state.serviceAggregation.allWireServices,
         },
-        serviceMetadata: state.serviceMetadata,
+        resolvedIOTypes: state.resolvedIOTypes,
+        middlewareGroupsMeta: state.middlewareGroupsMeta,
+        permissionsGroupsMeta: state.permissionsGroupsMeta,
+        requiredSchemas: Array.from(state.requiredSchemas),
+        openAPISpec: state.openAPISpec,
+        diagnostics: state.diagnostics,
     };
 }
 /**
@@ -118,6 +161,8 @@ export function deserializeInspectorState(data) {
             key,
             new Map(entries),
         ])),
+        schemaLookup: new Map(data.schemaLookup || []),
+        schemas: data.schemas || {},
         functions: {
             typesMap: deserializeTypesMap(data.functions.typesMap),
             meta: data.functions.meta,
@@ -134,6 +179,11 @@ export function deserializeInspectorState(data) {
             files: new Set(data.channels.files),
             meta: data.channels.meta,
         },
+        triggers: {
+            meta: data.triggers?.meta ?? {},
+            sourceMeta: data.triggers?.sourceMeta ?? {},
+            files: new Set(data.triggers?.files ?? []),
+        },
         scheduledTasks: {
             meta: data.scheduledTasks.meta,
             files: new Set(data.scheduledTasks.files),
@@ -145,6 +195,9 @@ 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 || []),
+            invokedWorkflows: new Set(data.workflows.invokedWorkflows || []),
         },
         rpc: {
             internalMeta: data.rpc.internalMeta,
@@ -152,6 +205,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,
@@ -159,16 +213,43 @@ export function deserializeInspectorState(data) {
             promptsMeta: data.mcpEndpoints.promptsMeta,
             files: new Set(data.mcpEndpoints.files),
         },
+        agents: {
+            agentsMeta: data.agents?.agentsMeta || {},
+            files: new Map(data.agents?.files || []),
+        },
         cli: {
             meta: data.cli.meta,
             files: new Set(data.cli.files),
         },
+        nodes: {
+            meta: data.nodes?.meta || {},
+            files: new Set(data.nodes?.files || []),
+        },
+        secrets: {
+            definitions: data.secrets?.definitions || [],
+            files: new Set(data.secrets?.files || []),
+        },
+        variables: {
+            definitions: data.variables?.definitions || [],
+            files: new Set(data.variables?.files || []),
+        },
+        manifest: data.manifest || { initial: null, current: null, errors: [] },
         middleware: {
-            meta: data.middleware.meta,
+            definitions: data.middleware.definitions,
+            instances: data.middleware.instances || {},
             tagMiddleware: new Map(data.middleware.tagMiddleware),
         },
+        channelMiddleware: {
+            definitions: data.channelMiddleware?.definitions || {},
+            instances: data.channelMiddleware?.instances || {},
+            tagMiddleware: new Map(data.channelMiddleware?.tagMiddleware || []),
+        },
+        aiMiddleware: {
+            definitions: data.aiMiddleware?.definitions || {},
+        },
         permissions: {
-            meta: data.permissions.meta,
+            definitions: data.permissions.definitions,
+            instances: data.permissions.instances || {},
             tagPermissions: new Map(data.permissions.tagPermissions),
         },
         serviceAggregation: {
@@ -179,6 +260,21 @@ export function deserializeInspectorState(data) {
             allSingletonServices: data.serviceAggregation.allSingletonServices,
             allWireServices: data.serviceAggregation.allWireServices,
         },
-        serviceMetadata: data.serviceMetadata || [],
+        resolvedIOTypes: data.resolvedIOTypes || {},
+        middlewareGroupsMeta: data.middlewareGroupsMeta || {
+            definitions: {},
+            instances: {},
+            httpGroups: {},
+            tagGroups: {},
+            channelMiddleware: { definitions: {}, instances: {}, tagGroups: {} },
+        },
+        permissionsGroupsMeta: data.permissionsGroupsMeta || {
+            definitions: {},
+            httpGroups: {},
+            tagGroups: {},
+        },
+        requiredSchemas: new Set(data.requiredSchemas || []),
+        openAPISpec: data.openAPISpec || null,
+        diagnostics: data.diagnostics || [],
     };
 }

package/dist/utils/serialize-mcp-json.d.ts

@@ -0,0 +1,2 @@
+import type { InspectorLogger, InspectorState } from '../types.js';
+export declare const serializeMCPJson: (logger: InspectorLogger, state: InspectorState) => string;

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

@@ -0,0 +1,99 @@
+export const serializeMCPJson = (logger, state) => {
+    const { mcpEndpoints, functions, schemas } = state;
+    const { meta: functionsMeta, typesMap } = functions;
+    const { resourcesMeta, toolsMeta, promptsMeta } = mcpEndpoints;
+    const tools = [];
+    const resources = [];
+    const prompts = [];
+    const loadSchema = (typeName) => {
+        if (!typeName ||
+            [
+                'boolean',
+                'string',
+                'number',
+                'null',
+                'undefined',
+                'void',
+                'unknown',
+                'never',
+            ].includes(typeName)) {
+            return undefined;
+        }
+        const uniqueName = typesMap.getUniqueName(typeName);
+        if (!uniqueName) {
+            return undefined;
+        }
+        const schema = schemas[uniqueName];
+        if (!schema) {
+            logger.warn(`Serialize MCP: Could not find schema for type: ${uniqueName}`);
+            return undefined;
+        }
+        return schema;
+    };
+    for (const [name, endpointMeta] of Object.entries(resourcesMeta)) {
+        const functionMeta = functionsMeta[endpointMeta.pikkuFuncId];
+        if (!functionMeta) {
+            logger.warn(`Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping resource ${name}.`);
+            continue;
+        }
+        const inputType = functionMeta.inputs?.[0];
+        const outputType = functionMeta.outputs?.[0];
+        const parameters = loadSchema(inputType);
+        const returns = loadSchema(outputType);
+        resources.push({
+            uri: name,
+            name,
+            description: endpointMeta.description,
+            ...(parameters && { parameters }),
+            ...(returns && { returns }),
+            ...(endpointMeta.streaming && { streaming: true }),
+        });
+    }
+    for (const [name, endpointMeta] of Object.entries(toolsMeta)) {
+        const functionMeta = functionsMeta[endpointMeta.pikkuFuncId];
+        if (!functionMeta) {
+            logger.warn(`Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping tool ${name}.`);
+            continue;
+        }
+        const inputType = functionMeta.inputs?.[0];
+        const outputType = functionMeta.outputs?.[0];
+        const parameters = loadSchema(inputType);
+        const returns = loadSchema(outputType);
+        tools.push({
+            name,
+            description: endpointMeta.description,
+            ...(parameters && { parameters }),
+            ...(returns && { returns }),
+            ...(endpointMeta.streaming && { streaming: true }),
+        });
+    }
+    for (const [name, endpointMeta] of Object.entries(promptsMeta)) {
+        const functionMeta = functionsMeta[endpointMeta.pikkuFuncId];
+        if (!functionMeta) {
+            logger.warn(`Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping prompt ${name}.`);
+            continue;
+        }
+        const inputType = functionMeta.inputs?.[0];
+        const inputSchema = loadSchema(inputType);
+        const argumentsArray = [];
+        if (inputSchema &&
+            typeof inputSchema === 'object' &&
+            !(inputSchema instanceof Array)) {
+            const properties = inputSchema.properties;
+            const required = inputSchema.required || [];
+            for (const [propName, propSchema] of Object.entries(properties)) {
+                argumentsArray.push({
+                    name: propName,
+                    description: propSchema.description || `${propName} parameter`,
+                    required: required.includes(propName),
+                });
+            }
+        }
+        prompts.push({
+            name,
+            description: endpointMeta.description,
+            arguments: argumentsArray,
+        });
+    }
+    return JSON.stringify({ tools, resources, prompts }, null, 2);
+};

package/dist/utils/serialize-middleware-groups-meta.d.ts

@@ -0,0 +1,12 @@
+import type { InspectorState } from '../types.js';
+export declare const serializeMiddlewareGroupsMeta: (state: InspectorState) => {
+    definitions: Record<string, import("../types.js").InspectorMiddlewareDefinition>;
+    instances: Record<string, import("../types.js").InspectorMiddlewareInstance>;
+    httpGroups: Record<string, any>;
+    tagGroups: Record<string, any>;
+    channelMiddleware: {
+        definitions: Record<string, import("../types.js").InspectorMiddlewareDefinition>;
+        instances: Record<string, import("../types.js").InspectorMiddlewareInstance>;
+        tagGroups: Record<string, any>;
+    };
+};