@pikku/core 0.12.2 → 0.12.4

package/dist/wirings/workflow/graph/graph-validation.js

@@ -0,0 +1,175 @@
+import { pikkuState } from '../../../pikku-state.js';
+import { resolveNamespace } from '../../rpc/rpc-runner.js';
+function normalizeTargets(value) {
+    if (!value)
+        return [];
+    if (typeof value === 'string')
+        return [value];
+    if (Array.isArray(value))
+        return value.filter((v) => typeof v === 'string');
+    if (typeof value === 'object') {
+        const targets = [];
+        for (const v of Object.values(value)) {
+            targets.push(...normalizeTargets(v));
+        }
+        return targets;
+    }
+    return [];
+}
+function collectRefs(value, refs) {
+    if (typeof value === 'object' &&
+        value !== null &&
+        '$ref' in value &&
+        typeof value.$ref === 'string') {
+        refs.add(value.$ref);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectRefs(item, refs);
+        return;
+    }
+    if (typeof value === 'object' && value !== null) {
+        for (const v of Object.values(value))
+            collectRefs(v, refs);
+    }
+}
+function resolveToolMeta(toolName) {
+    const resolved = toolName.includes(':') ? resolveNamespace(toolName) : null;
+    if (resolved) {
+        const fnMeta = pikkuState(resolved.package, 'function', 'meta')[resolved.function];
+        const schemas = pikkuState(resolved.package, 'misc', 'schemas');
+        return fnMeta ? { fnMeta, schemas } : null;
+    }
+    const rpcMeta = pikkuState(null, 'rpc', 'meta');
+    const pikkuFuncId = rpcMeta[toolName];
+    if (!pikkuFuncId)
+        return null;
+    const fnMeta = pikkuState(null, 'function', 'meta')[pikkuFuncId];
+    const schemas = pikkuState(null, 'misc', 'schemas');
+    return fnMeta ? { fnMeta, schemas } : null;
+}
+export function computeEntryNodeIds(nodes) {
+    const referenced = new Set();
+    for (const node of Object.values(nodes)) {
+        if (node.next) {
+            for (const target of normalizeTargets(node.next)) {
+                referenced.add(target);
+            }
+        }
+        if (node.onError) {
+            for (const target of normalizeTargets(node.onError)) {
+                referenced.add(target);
+            }
+        }
+    }
+    return Object.keys(nodes).filter((id) => !referenced.has(id));
+}
+export function validateWorkflowWiring(nodes, toolNames) {
+    const errors = [];
+    const nodeIds = new Set(Object.keys(nodes));
+    const toolSet = new Set(toolNames);
+    for (const [nodeId, node] of Object.entries(nodes)) {
+        if (!node.rpcName) {
+            errors.push(`Node '${nodeId}' is missing 'rpcName'`);
+            continue;
+        }
+        if (!toolSet.has(node.rpcName)) {
+            errors.push(`Node '${nodeId}' references unknown tool '${node.rpcName}'. Available tools: ${toolNames.join(', ')}`);
+            continue;
+        }
+        const nextTargets = normalizeTargets(node.next);
+        for (const target of nextTargets) {
+            if (!nodeIds.has(target)) {
+                errors.push(`Node '${nodeId}' routes to unknown node '${target}' in 'next'`);
+            }
+        }
+        const errorTargets = normalizeTargets(node.onError);
+        for (const target of errorTargets) {
+            if (!nodeIds.has(target)) {
+                errors.push(`Node '${nodeId}' routes to unknown node '${target}' in 'onError'`);
+            }
+        }
+        if (!node.input)
+            continue;
+        const refs = new Set();
+        collectRefs(node.input, refs);
+        for (const ref of refs) {
+            if (ref === 'trigger' || ref === '$item') {
+                const targetMeta = resolveToolMeta(node.rpcName);
+                if (targetMeta?.fnMeta?.inputSchemaName) {
+                    const targetSchema = targetMeta.schemas.get(targetMeta.fnMeta.inputSchemaName);
+                    if (targetSchema?.properties) {
+                        for (const [field, fieldValue] of Object.entries(node.input)) {
+                            if (typeof fieldValue === 'object' &&
+                                fieldValue !== null &&
+                                fieldValue.$ref === ref &&
+                                !fieldValue.path) {
+                                const targetType = targetSchema.properties[field]?.type;
+                                if (targetType && targetType !== 'object') {
+                                    errors.push(`Node '${nodeId}' input field '${field}' expects type '${targetType}', but references the whole ${ref} object without a path. Use { $ref: "${ref}", path: "${field}" } to extract the field.`);
+                                }
+                            }
+                        }
+                    }
+                }
+                continue;
+            }
+            if (!nodeIds.has(ref)) {
+                errors.push(`Node '${nodeId}' references unknown node '${ref}' in input`);
+                continue;
+            }
+            const sourceNode = nodes[ref];
+            if (!sourceNode?.rpcName)
+                continue;
+            const sourceMeta = resolveToolMeta(sourceNode.rpcName);
+            if (!sourceMeta?.fnMeta?.outputSchemaName)
+                continue;
+            const sourceSchema = sourceMeta.schemas.get(sourceMeta.fnMeta.outputSchemaName);
+            if (!sourceSchema?.properties)
+                continue;
+            for (const [field, fieldValue] of Object.entries(node.input)) {
+                if (typeof fieldValue === 'object' &&
+                    fieldValue !== null &&
+                    fieldValue.$ref === ref &&
+                    fieldValue.path) {
+                    const pathRoot = fieldValue.path.split('.')[0];
+                    if (sourceSchema.properties &&
+                        !(pathRoot in sourceSchema.properties)) {
+                        errors.push(`Node '${nodeId}' input field '${field}' references path '${fieldValue.path}' but node '${ref}' (${sourceNode.rpcName}) output has no property '${pathRoot}'`);
+                        continue;
+                    }
+                    const targetMeta = resolveToolMeta(node.rpcName);
+                    if (!targetMeta?.fnMeta?.inputSchemaName)
+                        continue;
+                    const targetSchema = targetMeta.schemas.get(targetMeta.fnMeta.inputSchemaName);
+                    if (!targetSchema?.properties?.[field])
+                        continue;
+                    const sourceType = sourceSchema.properties[pathRoot]?.type;
+                    const targetType = targetSchema.properties[field].type;
+                    if (sourceType && targetType && sourceType !== targetType) {
+                        errors.push(`Node '${nodeId}' input field '${field}' expects type '${targetType}', but node '${ref}' output field '${pathRoot}' is type '${sourceType}'`);
+                    }
+                }
+            }
+        }
+    }
+    return errors;
+}
+export function generateMermaidDiagram(workflowName, nodes, entryNodeIds) {
+    const lines = ['graph TD'];
+    for (const [nodeId, node] of Object.entries(nodes)) {
+        const label = node.rpcName || nodeId;
+        const isEntry = entryNodeIds.includes(nodeId);
+        lines.push(`  ${nodeId}${isEntry ? '([' : '['}${label}${isEntry ? '])' : ']'}`);
+        const nextTargets = normalizeTargets(node.next);
+        for (const target of nextTargets) {
+            lines.push(`  ${nodeId} --> ${target}`);
+        }
+        const errorTargets = normalizeTargets(node.onError);
+        for (const target of errorTargets) {
+            lines.push(`  ${nodeId} -.->|error| ${target}`);
+        }
+    }
+    return lines.join('\n');
+}

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

@@ -2,3 +2,4 @@ export { continueGraph, executeGraphStep, onGraphNodeComplete, runFromMeta, runW
 export { template } from './template.js';
 export type { TemplateString } from './template.js';
 export { pikkuWorkflowGraph, type PikkuWorkflowGraphConfig, type PikkuWorkflowGraphResult, } from './wire-workflow-graph.js';
+export { validateWorkflowWiring, computeEntryNodeIds, generateMermaidDiagram, } from './graph-validation.js';

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

@@ -1,3 +1,4 @@
 export { continueGraph, executeGraphStep, onGraphNodeComplete, runFromMeta, runWorkflowGraph, } from './graph-runner.js';
 export { template } from './template.js';
 export { pikkuWorkflowGraph, } from './wire-workflow-graph.js';
+export { validateWorkflowWiring, computeEntryNodeIds, generateMermaidDiagram, } from './graph-validation.js';

package/dist/wirings/workflow/index.d.ts

@@ -6,5 +6,5 @@ export { addWorkflow } from './dsl/workflow-runner.js';
 export { template, type TemplateString } from './graph/template.js';
 export { pikkuWorkflowGraph, type PikkuWorkflowGraphConfig, type PikkuWorkflowGraphResult, } from './graph/wire-workflow-graph.js';
 export { workflow, workflowStart, workflowStatus, graphStart, } from './workflow-helpers.js';
-export type { WorkflowService, WorkflowServiceConfig, WorkflowRunWire, WorkflowStatus, StepStatus, WorkflowRun, StepState, WorkflowRunService, CoreWorkflow, PikkuWorkflow, ContextVariable, WorkflowContext, WorkflowsMeta, WorkflowRuntimeMeta, WorkflowsRuntimeMeta, WorkflowStepInput, WorkflowOrchestratorInput, WorkflowSleeperInput, } from './workflow.types.js';
+export type { WorkflowService, WorkflowServiceConfig, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, StepStatus, WorkflowRun, StepState, WorkflowRunService, CoreWorkflow, PikkuWorkflow, ContextVariable, WorkflowContext, WorkflowsMeta, WorkflowRuntimeMeta, WorkflowsRuntimeMeta, WorkflowStepInput, WorkflowOrchestratorInput, WorkflowSleeperInput, } from './workflow.types.js';
 export type { WorkflowStepOptions, WorkflowWireDoRPC, WorkflowWireDoInline, WorkflowWireSleep, WorkflowWireSuspend, InputSource, OutputBinding, RpcStepMeta, SimpleCondition, Condition, BranchCase, BranchStepMeta, ParallelGroupStepMeta, FanoutStepMeta, ReturnStepMeta, InlineStepMeta, SleepStepMeta, CancelStepMeta, SetStepMeta, SwitchCaseMeta, SwitchStepMeta, FilterStepMeta, ArrayPredicateStepMeta, WorkflowStepMeta, WorkflowStepWire, PikkuWorkflowWire, } from './workflow.types.js';

package/dist/wirings/workflow/pikku-workflow-service.d.ts

@@ -1,5 +1,5 @@
 import type { SerializedError } from '../../types/core.types.js';
-import type { StepState, WorkflowRun, WorkflowRunWire, WorkflowStatus, WorkflowStepOptions } from './workflow.types.js';
+import type { StepState, WorkflowRun, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, WorkflowStepOptions } from './workflow.types.js';
 import type { WorkflowService } from '../../services/workflow-service.js';
 import { PikkuError } from '../../errors/error-handler.js';
 /**
@@ -197,11 +197,17 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
      * @returns The state object with all variables
      */
     abstract getRunState(runId: string): Promise<Record<string, unknown>>;
-    abstract upsertWorkflowVersion(name: string, graphHash: string, graph: any, source: string): Promise<void>;
+    abstract upsertWorkflowVersion(name: string, graphHash: string, graph: any, source: string, status?: WorkflowVersionStatus): Promise<void>;
+    abstract updateWorkflowVersionStatus(name: string, graphHash: string, status: WorkflowVersionStatus): Promise<void>;
     abstract getWorkflowVersion(name: string, graphHash: string): Promise<{
         graph: any;
         source: string;
     } | null>;
+    abstract getAIGeneratedWorkflows(agentName?: string): Promise<Array<{
+        workflowName: string;
+        graphHash: string;
+        graph: any;
+    }>>;
     /**
      * Resume a paused workflow by triggering the orchestrator
      * @param runId - Run ID

package/dist/wirings/workflow/pikku-workflow-service.js

@@ -162,8 +162,7 @@ export class PikkuWorkflowService {
         if (!workflowMeta) {
             throw new WorkflowNotFoundError(name);
         }
-        // Check if this is a graph workflow (source === 'graph')
-        if (workflowMeta.source === 'graph') {
+        if (workflowMeta.source === 'graph' || workflowMeta.source === 'ai-agent') {
             const shouldInline = options?.inline || !getSingletonServices()?.queueService;
             return runWorkflowGraph(this, name, input, rpcService, shouldInline, options?.startNode, wire);
         }

package/dist/wirings/workflow/workflow.types.d.ts

@@ -19,6 +19,10 @@ export interface WorkflowServiceConfig {
  * Workflow run status
  */
 export type WorkflowStatus = 'running' | 'suspended' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Workflow version status (for AI-generated workflows)
+ */
+export type WorkflowVersionStatus = 'draft' | 'active' | 'declined';
 /**
  * Workflow step status
  */
@@ -102,6 +106,11 @@ export interface WorkflowRunService {
         graph: any;
         source: string;
     } | null>;
+    getAIGeneratedWorkflows(agentName?: string): Promise<Array<{
+        workflowName: string;
+        graphHash: string;
+        graph: any;
+    }>>;
     deleteRun(id: string): Promise<boolean>;
 }
 /**
@@ -167,7 +176,7 @@ export interface WorkflowRuntimeMeta {
     /** Pikku function name (for execution) */
     pikkuFuncId: string;
     /** Source type: 'dsl' (serializable), 'complex' (has inline steps), 'graph' */
-    source: 'dsl' | 'complex' | 'graph';
+    source: 'dsl' | 'complex' | 'graph' | 'ai-agent';
     /** Optional description */
     description?: string;
     /** Tags for organization */