@pikku/inspector 0.11.2 → 0.12.0

package/dist/utils/workflow/graph/finalize-workflow-wires.js

@@ -0,0 +1,276 @@
+function parseWorkflowFuncId(pikkuFuncId) {
+    for (const prefix of ['workflowStart:', 'workflow:']) {
+        if (pikkuFuncId.startsWith(prefix)) {
+            return { workflowName: pikkuFuncId.slice(prefix.length) };
+        }
+    }
+    if (pikkuFuncId.startsWith('graphStart:')) {
+        const rest = pikkuFuncId.slice('graphStart:'.length);
+        const colonIdx = rest.indexOf(':');
+        if (colonIdx !== -1) {
+            return {
+                workflowName: rest.slice(0, colonIdx),
+                startNode: rest.slice(colonIdx + 1),
+            };
+        }
+    }
+    return null;
+}
+function resolveStartNode(parsed, graph) {
+    return parsed.startNode ?? graph.entryNodeIds[0];
+}
+function getOrCreateWires(graph) {
+    if (!graph.wires) {
+        graph.wires = {};
+    }
+    return graph.wires;
+}
+export function finalizeWorkflowHelperTypes(state) {
+    const { functions, workflows } = state;
+    const graphMeta = workflows.graphMeta;
+    for (const meta of Object.values(functions.meta)) {
+        if (meta.functionType !== 'helper')
+            continue;
+        if (meta.pikkuFuncId.startsWith('workflowStatus:'))
+            continue;
+        const parsed = parseWorkflowFuncId(meta.pikkuFuncId);
+        if (!parsed)
+            continue;
+        const graph = graphMeta[parsed.workflowName];
+        if (!graph)
+            continue;
+        const startNodeId = resolveStartNode(parsed, graph);
+        const startNode = graph.nodes[startNodeId];
+        if (!startNode || !('rpcName' in startNode))
+            continue;
+        const rpcMeta = functions.meta[startNode.rpcName];
+        if (!rpcMeta)
+            continue;
+        if (rpcMeta.inputSchemaName) {
+            meta.inputSchemaName = rpcMeta.inputSchemaName;
+        }
+        if (rpcMeta.inputs && rpcMeta.inputs.length > 0) {
+            meta.inputs = rpcMeta.inputs;
+        }
+    }
+}
+export function finalizeWorkflowWires(state) {
+    const { workflows } = state;
+    const graphMeta = workflows.graphMeta;
+    scanHTTP(state, graphMeta);
+    scanScheduledTasks(state, graphMeta);
+    scanTriggers(state, graphMeta);
+    scanQueueWorkers(state, graphMeta);
+    scanChannels(state, graphMeta);
+    scanMCPEndpoints(state, graphMeta);
+    scanCLI(state, graphMeta);
+}
+function scanHTTP(state, graphMeta) {
+    for (const [method, routes] of Object.entries(state.http.meta)) {
+        for (const [route, meta] of Object.entries(routes)) {
+            const parsed = parseWorkflowFuncId(meta.pikkuFuncId);
+            if (!parsed)
+                continue;
+            const graph = graphMeta[parsed.workflowName];
+            if (!graph)
+                continue;
+            const wires = getOrCreateWires(graph);
+            if (!wires.http)
+                wires.http = [];
+            wires.http.push({
+                route,
+                method,
+                startNode: resolveStartNode(parsed, graph),
+            });
+        }
+    }
+}
+function scanScheduledTasks(state, graphMeta) {
+    for (const meta of Object.values(state.scheduledTasks.meta)) {
+        const parsed = parseWorkflowFuncId(meta.pikkuFuncId);
+        if (!parsed)
+            continue;
+        const graph = graphMeta[parsed.workflowName];
+        if (!graph)
+            continue;
+        const wires = getOrCreateWires(graph);
+        if (!wires.schedule)
+            wires.schedule = [];
+        wires.schedule.push({
+            cron: meta.schedule,
+            startNode: resolveStartNode(parsed, graph),
+        });
+    }
+}
+function scanTriggers(state, graphMeta) {
+    for (const meta of Object.values(state.triggers.meta)) {
+        const parsed = parseWorkflowFuncId(meta.pikkuFuncId);
+        if (!parsed)
+            continue;
+        const graph = graphMeta[parsed.workflowName];
+        if (!graph)
+            continue;
+        const wires = getOrCreateWires(graph);
+        if (!wires.trigger)
+            wires.trigger = [];
+        wires.trigger.push({
+            name: meta.name,
+            startNode: resolveStartNode(parsed, graph),
+        });
+    }
+}
+function scanQueueWorkers(state, graphMeta) {
+    for (const meta of Object.values(state.queueWorkers.meta)) {
+        const parsed = parseWorkflowFuncId(meta.pikkuFuncId);
+        if (!parsed)
+            continue;
+        const graph = graphMeta[parsed.workflowName];
+        if (!graph)
+            continue;
+        const wires = getOrCreateWires(graph);
+        if (!wires.queue)
+            wires.queue = [];
+        wires.queue.push({
+            name: meta.name,
+            startNode: resolveStartNode(parsed, graph),
+        });
+    }
+}
+function scanChannels(state, graphMeta) {
+    for (const channelMeta of Object.values(state.channels.meta)) {
+        const wire = {
+            name: channelMeta.name,
+            route: channelMeta.route,
+        };
+        let targetWorkflow;
+        if (channelMeta.connect) {
+            const parsed = parseWorkflowFuncId(channelMeta.connect.pikkuFuncId);
+            if (parsed) {
+                const graph = graphMeta[parsed.workflowName];
+                if (graph) {
+                    targetWorkflow = graph;
+                    wire.onConnect = resolveStartNode(parsed, graph);
+                }
+            }
+        }
+        if (channelMeta.disconnect) {
+            const parsed = parseWorkflowFuncId(channelMeta.disconnect.pikkuFuncId);
+            if (parsed) {
+                const graph = graphMeta[parsed.workflowName];
+                if (graph) {
+                    targetWorkflow = targetWorkflow ?? graph;
+                    wire.onDisconnect = resolveStartNode(parsed, graph);
+                }
+            }
+        }
+        if (channelMeta.message) {
+            const parsed = parseWorkflowFuncId(channelMeta.message.pikkuFuncId);
+            if (parsed) {
+                const graph = graphMeta[parsed.workflowName];
+                if (graph) {
+                    targetWorkflow = targetWorkflow ?? graph;
+                    wire.onMessage = resolveStartNode(parsed, graph);
+                }
+            }
+        }
+        for (const [routingProp, routeMap] of Object.entries(channelMeta.messageWirings)) {
+            for (const [routeValue, messageMeta] of Object.entries(routeMap)) {
+                const parsed = parseWorkflowFuncId(messageMeta.pikkuFuncId);
+                if (!parsed)
+                    continue;
+                const graph = graphMeta[parsed.workflowName];
+                if (!graph)
+                    continue;
+                targetWorkflow = targetWorkflow ?? graph;
+                if (!wire.onMessageRoute)
+                    wire.onMessageRoute = {};
+                wire.onMessageRoute[`${routingProp}:${routeValue}`] = resolveStartNode(parsed, graph);
+            }
+        }
+        if (targetWorkflow) {
+            const wires = getOrCreateWires(targetWorkflow);
+            if (!wires.channel)
+                wires.channel = [];
+            wires.channel.push(wire);
+        }
+    }
+}
+function scanMCPEndpoints(state, graphMeta) {
+    for (const meta of Object.values(state.mcpEndpoints.toolsMeta)) {
+        const parsed = parseWorkflowFuncId(meta.pikkuFuncId);
+        if (!parsed)
+            continue;
+        const graph = graphMeta[parsed.workflowName];
+        if (!graph)
+            continue;
+        const wires = getOrCreateWires(graph);
+        if (!wires.mcp)
+            wires.mcp = {};
+        if (!wires.mcp.tool)
+            wires.mcp.tool = [];
+        wires.mcp.tool.push({
+            name: meta.name,
+            startNode: resolveStartNode(parsed, graph),
+        });
+    }
+    for (const meta of Object.values(state.mcpEndpoints.promptsMeta)) {
+        const parsed = parseWorkflowFuncId(meta.pikkuFuncId);
+        if (!parsed)
+            continue;
+        const graph = graphMeta[parsed.workflowName];
+        if (!graph)
+            continue;
+        const wires = getOrCreateWires(graph);
+        if (!wires.mcp)
+            wires.mcp = {};
+        if (!wires.mcp.prompt)
+            wires.mcp.prompt = [];
+        wires.mcp.prompt.push({
+            name: meta.name,
+            startNode: resolveStartNode(parsed, graph),
+        });
+    }
+    for (const meta of Object.values(state.mcpEndpoints.resourcesMeta)) {
+        const parsed = parseWorkflowFuncId(meta.pikkuFuncId);
+        if (!parsed)
+            continue;
+        const graph = graphMeta[parsed.workflowName];
+        if (!graph)
+            continue;
+        const wires = getOrCreateWires(graph);
+        if (!wires.mcp)
+            wires.mcp = {};
+        if (!wires.mcp.resource)
+            wires.mcp.resource = [];
+        wires.mcp.resource.push({
+            uri: meta.uri,
+            startNode: resolveStartNode(parsed, graph),
+        });
+    }
+}
+function visitCLICommands(commands, programName, path, graphMeta) {
+    for (const [name, command] of Object.entries(commands)) {
+        const currentPath = [...path, name];
+        const parsed = parseWorkflowFuncId(command.pikkuFuncId);
+        if (parsed) {
+            const graph = graphMeta[parsed.workflowName];
+            if (graph) {
+                const wires = getOrCreateWires(graph);
+                if (!wires.cli)
+                    wires.cli = [];
+                wires.cli.push({
+                    command: `${programName} ${currentPath.join(' ')}`,
+                    startNode: resolveStartNode(parsed, graph),
+                });
+            }
+        }
+        if (command.subcommands) {
+            visitCLICommands(command.subcommands, programName, currentPath, graphMeta);
+        }
+    }
+}
+function scanCLI(state, graphMeta) {
+    for (const program of Object.values(state.cli.meta.programs)) {
+        visitCLICommands(program.commands, program.program, [], graphMeta);
+    }
+}

package/dist/utils/workflow/graph/finalize-workflows.d.ts

@@ -0,0 +1,2 @@
+import type { InspectorState } from '../../../types.js';
+export declare function finalizeWorkflows(state: InspectorState): void;

package/dist/utils/workflow/graph/finalize-workflows.js

@@ -0,0 +1,75 @@
+import { isVersionedId, formatVersionedId, parseVersionedId } from '@pikku/core';
+import { canonicalJSON, hashString } from '../../hash.js';
+import { convertDslToGraph } from './convert-dsl-to-graph.js';
+export function finalizeWorkflows(state) {
+    const { workflows, functions } = state;
+    const functionsMeta = functions.meta;
+    for (const [name, meta] of Object.entries(workflows.meta)) {
+        const graph = convertDslToGraph(name, meta);
+        stampVersionsOnGraph(graph, functionsMeta);
+        computeStepHashes(graph, functionsMeta);
+        graph.graphHash = computeGraphHash(graph);
+        workflows.graphMeta[name] = graph;
+    }
+    for (const graph of Object.values(workflows.graphMeta)) {
+        if (graph.graphHash) {
+            continue;
+        }
+        stampVersionsOnGraph(graph, functionsMeta);
+        computeStepHashes(graph, functionsMeta);
+        graph.graphHash = computeGraphHash(graph);
+    }
+}
+function stampVersionsOnGraph(graph, functionsMeta) {
+    for (const node of Object.values(graph.nodes)) {
+        if (!('rpcName' in node) || typeof node.rpcName !== 'string') {
+            continue;
+        }
+        if (isVersionedId(node.rpcName)) {
+            continue;
+        }
+        const meta = functionsMeta[node.rpcName];
+        if (meta?.version !== undefined) {
+            node.rpcName = formatVersionedId(node.rpcName, meta.version);
+        }
+        else {
+            const latestVersion = findLatestVersion(node.rpcName, functionsMeta);
+            if (latestVersion > 0) {
+                node.rpcName = formatVersionedId(node.rpcName, latestVersion);
+            }
+        }
+    }
+}
+function findLatestVersion(baseName, functionsMeta) {
+    let max = 0;
+    for (const id of Object.keys(functionsMeta)) {
+        const parsed = parseVersionedId(id);
+        if (parsed.baseName === baseName && parsed.version !== null) {
+            max = Math.max(max, parsed.version);
+        }
+    }
+    return max;
+}
+function computeStepHashes(graph, functionsMeta) {
+    for (const node of Object.values(graph.nodes)) {
+        if (!('rpcName' in node) || typeof node.rpcName !== 'string') {
+            continue;
+        }
+        const rpcName = node.rpcName;
+        let meta = functionsMeta[rpcName];
+        if (!meta) {
+            const { baseName } = parseVersionedId(rpcName);
+            meta = functionsMeta[baseName];
+        }
+        ;
+        node.stepHash = hashString(`${node.nodeId}:${meta?.contractHash ?? ''}`, 12);
+    }
+}
+function computeGraphHash(graph) {
+    return hashString(canonicalJSON({
+        source: graph.source,
+        context: graph.context,
+        nodes: graph.nodes,
+        entryNodeIds: graph.entryNodeIds,
+    }), 12);
+}

package/dist/utils/workflow/graph/index.d.ts

@@ -4,3 +4,5 @@
 export * from './workflow-graph.types.js';
 export { serializeWorkflowGraph } from './serialize-workflow-graph.js';
 export { convertDslToGraph } from './convert-dsl-to-graph.js';
+export { finalizeWorkflows } from './finalize-workflows.js';
+export { finalizeWorkflowHelperTypes, finalizeWorkflowWires, } from './finalize-workflow-wires.js';

package/dist/utils/workflow/graph/index.js

@@ -4,3 +4,5 @@
 export * from './workflow-graph.types.js';
 export { serializeWorkflowGraph } from './serialize-workflow-graph.js';
 export { convertDslToGraph } from './convert-dsl-to-graph.js';
+export { finalizeWorkflows } from './finalize-workflows.js';
+export { finalizeWorkflowHelperTypes, finalizeWorkflowWires, } from './finalize-workflow-wires.js';

package/dist/utils/workflow/graph/serialize-workflow-graph.d.ts

@@ -7,13 +7,6 @@ import type { SerializedWorkflowGraph, DataRef, SerializedNext } from './workflo
  */
 export declare function serializeWorkflowGraph(definition: {
     name: string;
-    wires: {
-        http?: {
-            route: string;
-            method: string;
-        };
-        queue?: string;
-    };
     graph: Record<string, {
         func: {
             name?: string;
@@ -32,7 +25,6 @@ export declare function serializeWorkflowGraph(definition: {
  */
 export declare function deserializeWorkflowGraph(serialized: SerializedWorkflowGraph): {
     name: string;
-    wires: SerializedWorkflowGraph['wires'];
     graph: Record<string, {
         rpcName: string;
         input: Record<string, unknown | DataRef>;

package/dist/utils/workflow/graph/serialize-workflow-graph.js

@@ -116,11 +116,10 @@ export function serializeWorkflowGraph(definition, options) {
     }
     return {
         name: definition.name,
-        pikkuFuncName: definition.name, // For graph workflows, pikkuFuncName is the workflow name
+        pikkuFuncId: definition.name, // For graph workflows, pikkuFuncId is the workflow name
         source: 'graph',
         description: options?.description,
         tags: options?.tags,
-        wires: definition.wires,
         nodes,
         entryNodeIds,
     };
@@ -145,7 +144,6 @@ export function deserializeWorkflowGraph(serialized) {
     }
     return {
         name: serialized.name,
-        wires: serialized.wires,
         graph,
         entryNodeIds: serialized.entryNodeIds,
     };

package/dist/utils/workflow/graph/workflow-graph.types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Serialized types for workflow graphs
  * These are extracted by the inspector and stored as JSON
- * Can be created from code (wireWorkflow) or UI
+ * Can be created from code (pikkuWorkflowGraph) or UI
  */
 /**
  * Reference to data from another node or trigger
@@ -96,6 +96,8 @@ export interface FunctionNode extends BaseNode {
     input?: Record<string, unknown | DataRef>;
     /** Output variable name for storing result */
     outputVar?: string;
+    /** Hash of nodeId + RPC input/output schemas for version detection */
+    stepHash?: string;
 }
 /**
  * Flow node - control flow only, no RPC call
@@ -118,81 +120,6 @@ export declare const isFunctionNode: (node: SerializedGraphNode) => node is Func
  * Type guard for flow nodes
  */
 export declare const isFlowNode: (node: SerializedGraphNode) => node is FlowNode;
-/**
- * HTTP wire configuration with startNode
- */
-export interface HttpWire {
-    route: string;
-    method: 'get' | 'post' | 'put' | 'patch' | 'delete';
-    startNode: string;
-}
-/**
- * Channel wire configuration
- */
-export interface ChannelWire {
-    name: string;
-    onConnect?: string;
-    onDisconnect?: string;
-    onMessage?: string;
-}
-/**
- * Queue wire configuration
- */
-export interface QueueWire {
-    name: string;
-    startNode: string;
-}
-/**
- * CLI wire configuration
- */
-export interface CliWire {
-    command: string;
-    startNode: string;
-}
-/**
- * MCP wire configurations
- */
-export interface McpWires {
-    tool?: Array<{
-        name: string;
-        startNode: string;
-    }>;
-    prompt?: Array<{
-        name: string;
-        startNode: string;
-    }>;
-    resource?: Array<{
-        uri: string;
-        startNode: string;
-    }>;
-}
-/**
- * Schedule wire configuration
- */
-export interface ScheduleWire {
-    cron?: string;
-    interval?: string;
-    startNode: string;
-}
-/**
- * Trigger wire configuration
- */
-export interface TriggerWire {
-    name: string;
-    startNode: string;
-}
-/**
- * All wire configurations for workflows
- */
-export interface WorkflowWiresConfig {
-    http?: HttpWire[];
-    channel?: ChannelWire[];
-    queue?: QueueWire[];
-    cli?: CliWire[];
-    mcp?: McpWires;
-    schedule?: ScheduleWire[];
-    trigger?: TriggerWire[];
-}
 /**
  * Workflow source type
  * - 'dsl': Pure DSL workflow (pikkuWorkflowFunc) - can be round-tripped to code
@@ -207,7 +134,7 @@ export interface SerializedWorkflowGraph {
     /** Workflow name */
     name: string;
     /** Pikku function name (for runtime registration) */
-    pikkuFuncName: string;
+    pikkuFuncId: string;
     /** Source type: 'dsl' for pikkuWorkflowFunc, 'graph' for pikkuWorkflowGraph */
     source: WorkflowSourceType;
     /** Optional description */
@@ -216,12 +143,59 @@ export interface SerializedWorkflowGraph {
     tags?: string[];
     /** Workflow context/state variables (from Zod schema) */
     context?: WorkflowContext;
-    /** Wires - how the workflow is triggered */
-    wires: WorkflowWiresConfig;
     /** Serialized nodes */
     nodes: Record<string, SerializedGraphNode>;
     /** Entry node(s) - first nodes to execute */
     entryNodeIds: string[];
+    /** Hash of graph topology (nodes, edges, input mappings) */
+    graphHash?: string;
+    /** Wire entry points (HTTP, channel, queue, etc.) that trigger this workflow */
+    wires?: WorkflowWires;
+}
+export interface WorkflowWires {
+    http?: Array<{
+        route: string;
+        method: string;
+        startNode: string;
+    }>;
+    channel?: Array<{
+        name: string;
+        route: string;
+        onConnect?: string;
+        onMessage?: string;
+        onDisconnect?: string;
+        onMessageRoute?: Record<string, string>;
+    }>;
+    queue?: Array<{
+        name: string;
+        startNode: string;
+    }>;
+    cli?: Array<{
+        command: string;
+        startNode: string;
+    }>;
+    mcp?: {
+        tool?: Array<{
+            name: string;
+            startNode: string;
+        }>;
+        prompt?: Array<{
+            name: string;
+            startNode: string;
+        }>;
+        resource?: Array<{
+            uri: string;
+            startNode: string;
+        }>;
+    };
+    schedule?: Array<{
+        cron: string;
+        startNode: string;
+    }>;
+    trigger?: Array<{
+        name: string;
+        startNode: string;
+    }>;
 }
 /**
  * All workflow graphs (serialized)

package/dist/utils/workflow/graph/workflow-graph.types.js

@@ -1,7 +1,7 @@
 /**
  * Serialized types for workflow graphs
  * These are extracted by the inspector and stored as JSON
- * Can be created from code (wireWorkflow) or UI
+ * Can be created from code (pikkuWorkflowGraph) or UI
  */
 /**
  * Check if value is a DataRef

package/dist/visit.js

@@ -2,11 +2,12 @@ import * as ts from 'typescript';
 import { addFileWithFactory } from './add/add-file-with-factory.js';
 import { addFileExtendsCoreType } from './add/add-file-extends-core-type.js';
 import { addHTTPRoute } from './add/add-http-route.js';
+import { addHTTPRoutes } from './add/add-http-routes.js';
 import { addSchedule } from './add/add-schedule.js';
+import { addTrigger } from './add/add-trigger.js';
 import { addQueueWorker } from './add/add-queue-worker.js';
 import { addWorkflow } from './add/add-workflow.js';
 import { addMCPResource } from './add/add-mcp-resource.js';
-import { addMCPTool } from './add/add-mcp-tool.js';
 import { addMCPPrompt } from './add/add-mcp-prompt.js';
 import { addFunctions } from './add/add-functions.js';
 import { addChannel } from './add/add-channel.js';
@@ -14,9 +15,10 @@ import { addRPCInvocations } from './add/add-rpc-invocations.js';
 import { addMiddleware } from './add/add-middleware.js';
 import { addPermission } from './add/add-permission.js';
 import { addCLI, addCLIRenderers } from './add/add-cli.js';
-import { addForgeNode } from './add/add-forge-node.js';
-import { addForgeCredential } from './add/add-forge-credential.js';
+import { addSecret, addOAuth2Credential } from './add/add-secret.js';
+import { addVariable } from './add/add-variable.js';
 import { addWorkflowGraph } from './add/add-workflow-graph.js';
+import { addAIAgent } from './add/add-ai-agent.js';
 export const visitSetup = (logger, checker, node, state, options) => {
     addFileExtendsCoreType(node, checker, state.singletonServicesTypeImportMap, 'CoreSingletonServices', state);
     addFileExtendsCoreType(node, checker, state.wireServicesTypeImportMap, 'CoreServices', state);
@@ -33,17 +35,20 @@ export const visitSetup = (logger, checker, node, state, options) => {
 };
 export const visitRoutes = (logger, checker, node, state, options) => {
     addFunctions(logger, node, checker, state, options);
+    addSecret(logger, node, checker, state, options);
+    addOAuth2Credential(logger, node, checker, state, options);
+    addVariable(logger, node, checker, state, options);
     addHTTPRoute(logger, node, checker, state, options);
+    addHTTPRoutes(logger, node, checker, state, options);
     addSchedule(logger, node, checker, state, options);
+    addTrigger(logger, node, checker, state, options);
     addQueueWorker(logger, node, checker, state, options);
     addChannel(logger, node, checker, state, options);
     addCLI(logger, node, checker, state, options);
     addCLIRenderers(logger, node, checker, state, options);
     addMCPResource(logger, node, checker, state, options);
-    addMCPTool(logger, node, checker, state, options);
     addMCPPrompt(logger, node, checker, state, options);
-    addForgeNode(logger, node, checker, state, options);
-    addForgeCredential(logger, node, checker, state, options);
     addWorkflowGraph(logger, node, checker, state, options);
+    addAIAgent(logger, node, checker, state, options);
     ts.forEachChild(node, (child) => visitRoutes(logger, checker, child, state, options));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.11.2",
+  "version": "0.12.0",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "type": "module",
@@ -12,6 +12,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./schema-generator": {
+      "types": "./dist/schema-generator.d.ts",
+      "import": "./dist/schema-generator.js",
+      "default": "./dist/schema-generator.js"
+    },
     "./workflow-graph": {
       "types": "./dist/utils/workflow/graph/index.d.ts",
       "import": "./dist/utils/workflow/graph/index.js",
@@ -28,12 +33,17 @@
     "test:coverage": "bash run-tests.sh --coverage"
   },
   "dependencies": {
-    "@pikku/core": "^0.11.2",
+    "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.1",
+    "@pikku/core": "^0.12.0",
     "path-to-regexp": "^8.3.0",
-    "typescript": "^5.9"
+    "ts-json-schema-generator": "^2.5.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9",
+    "zod": "^4.3.6",
+    "zod-to-ts": "^2.0.0"
   },
   "devDependencies": {
-    "@types/node": "^24.10.1"
+    "@types/node": "^24.10.12"
   },
   "engines": {
     "node": ">=18"