[One Workflow] Implement outputs, workflow.output and workflow.fail steps

src/platform/packages/shared/kbn-workflows/graph/build_execution_graph/build_execution_graph.ts

@@ -30,7 +30,9 @@ import type {
   WhileStep,
   WorkflowExecuteAsyncStep,
   WorkflowExecuteStep,
+  WorkflowFailStep,
   WorkflowOnFailure,
+  WorkflowOutputStep,
   WorkflowRetry,
   WorkflowSettings,
   WorkflowYaml,
@@ -62,6 +64,7 @@ import type {
   LoopEnterNode,
   WaitForInputGraphNode,
   WorkflowGraphType,
+  WorkflowOutputGraphNode,
 } from '../types';
 import { isLoopEnterNode } from '../types';
 import { createTypedGraph } from '../workflow_graph/create_typed_graph';
@@ -183,6 +186,20 @@ function visitAbstractStep(currentStep: BaseStep, context: GraphBuildContext): W
     return visitWorkflowExecuteAsyncStep(currentStep as WorkflowExecuteAsyncStep, context);
   }
 
+  if (currentStep.type === 'workflow.output') {
+    return visitWorkflowOutputStep(currentStep, context);
+  }
+
+  if (currentStep.type === 'workflow.fail') {
+    const transformedStep: WorkflowOutputStep = {
+      ...currentStep,
+      type: 'workflow.output',
+      status: 'failed',
+      with: (currentStep as WorkflowFailStep).with ?? {},
+    };
+    return visitWorkflowOutputStep(transformedStep, context);
+  }
+
   return visitAtomicStep(currentStep, context);
 }
 
@@ -288,6 +305,23 @@ export function visitWorkflowExecuteAsyncStep(
   return createLeafStepGraph(currentStep, context, 'workflow.executeAsync');
 }
 
+export function visitWorkflowOutputStep(
+  currentStep: BaseStep,
+  context: GraphBuildContext
+): WorkflowGraphType {
+  const stepId = getStepId(currentStep, context);
+  const graph = createTypedGraph({ directed: true });
+  const workflowOutputNode: WorkflowOutputGraphNode = {
+    id: stepId,
+    type: 'workflow.output',
+    stepId,
+    stepType: 'workflow.output',
+    configuration: currentStep as WorkflowOutputStep,
+  };
+  graph.setNode(workflowOutputNode.id, workflowOutputNode);
+  return graph;
+}
+
 export function visitAtomicStep(
   currentStep: BaseStep,
   context: GraphBuildContext

src/platform/packages/shared/kbn-workflows/graph/index.ts

@@ -57,6 +57,8 @@ export type {
   WorkflowExecuteGraphNodeSchema,
   WorkflowExecuteAsyncGraphNode,
   WorkflowExecuteAsyncGraphNodeSchema,
+  WorkflowOutputGraphNode,
+  WorkflowOutputGraphNodeSchema,
   LoopEnterNode,
 } from './types';
 

src/platform/packages/shared/kbn-workflows/graph/types/guards.ts

@@ -14,6 +14,7 @@ import type {
   KibanaGraphNode,
   WaitForInputGraphNode,
   WaitGraphNode,
+  WorkflowOutputGraphNode,
 } from './nodes/base';
 import type {
   EnterConditionBranchNode,
@@ -60,6 +61,9 @@ export const isWaitForInput = (node: GraphNodeUnion): node is WaitForInputGraphN
 export const isDataSet = (node: GraphNodeUnion): node is DataSetGraphNode =>
   node.type === 'data.set';
 
+export const isWorkflowOutput = (node: GraphNodeUnion): node is WorkflowOutputGraphNode =>
+  node.type === 'workflow.output';
+
 export const isEnterIf = (node: GraphNodeUnion): node is EnterIfNode => node.type === 'enter-if';
 
 export const isExitIf = (node: GraphNodeUnion): node is ExitIfNode => node.type === 'exit-if';

src/platform/packages/shared/kbn-workflows/graph/types/index.ts

@@ -24,6 +24,8 @@ export type {
   WorkflowExecuteGraphNodeSchema,
   WorkflowExecuteAsyncGraphNode,
   WorkflowExecuteAsyncGraphNodeSchema,
+  WorkflowOutputGraphNode,
+  WorkflowOutputGraphNodeSchema,
 } from './nodes/base';
 export type {
   EnterConditionBranchNode,
@@ -89,6 +91,7 @@ export {
   isKibana,
   isWait,
   isWaitForInput,
+  isWorkflowOutput,
   isEnterForeach,
   isEnterWhile,
   isEnterIf,

src/platform/packages/shared/kbn-workflows/graph/types/nodes/base.ts

@@ -16,6 +16,7 @@ import {
   WaitStepSchema,
   WorkflowExecuteAsyncStepSchema,
   WorkflowExecuteStepSchema,
+  WorkflowOutputStepSchema,
 } from '../../../spec/schema';
 
 export const GraphNodeSchema = z.object({
@@ -84,3 +85,10 @@ export const WorkflowExecuteAsyncGraphNodeSchema = GraphNodeSchema.extend({
   configuration: WorkflowExecuteAsyncStepSchema,
 });
 export type WorkflowExecuteAsyncGraphNode = z.infer<typeof WorkflowExecuteAsyncGraphNodeSchema>;
+
+export const WorkflowOutputGraphNodeSchema = GraphNodeSchema.extend({
+  id: z.string(),
+  type: z.literal('workflow.output'),
+  configuration: WorkflowOutputStepSchema,
+});
+export type WorkflowOutputGraphNode = z.infer<typeof WorkflowOutputGraphNodeSchema>;

src/platform/packages/shared/kbn-workflows/graph/types/nodes/union.ts

@@ -17,6 +17,7 @@ import {
   WaitGraphNodeSchema,
   WorkflowExecuteAsyncGraphNodeSchema,
   WorkflowExecuteGraphNodeSchema,
+  WorkflowOutputGraphNodeSchema,
 } from './base';
 import {
   EnterConditionBranchNodeSchema,
@@ -58,6 +59,7 @@ const GraphNodeUnionSchema = z.discriminatedUnion('type', [
   WaitForInputGraphNodeSchema,
   WorkflowExecuteGraphNodeSchema,
   WorkflowExecuteAsyncGraphNodeSchema,
+  WorkflowOutputGraphNodeSchema,
   EnterIfNodeSchema,
   ExitIfNodeSchema,
   EnterConditionBranchNodeSchema,

src/platform/packages/shared/kbn-workflows/index.ts

@@ -7,6 +7,7 @@
  * License v3.0 only", or the "Server Side Public License, v 1".
  */
 
+export * from './spec/lib/build_fields_zod_validator';
 export * from './spec/lib/build_step_schema_for_agent';
 export * from './spec/lib/generate_yaml_schema_from_connectors';
 export * from './spec/lib/get_workflow_json_schema';

src/platform/plugins/shared/workflows_management/common/lib/json_schema_to_zod.test.ts → src/platform/packages/shared/kbn-workflows/spec/lib/build_fields_zod_validator.test.ts

@@ -9,10 +9,10 @@
 
 import type { JSONSchema7 } from 'json-schema';
 import {
-  buildInputsZodValidator,
+  buildFieldsZodValidator,
   convertJsonSchemaToZod,
   convertJsonSchemaToZodWithRefs,
-} from './json_schema_to_zod';
+} from './build_fields_zod_validator';
 
 describe('convertJsonSchemaToZod', () => {
   it('should convert a string schema to Zod', () => {
@@ -384,11 +384,11 @@ describe('convertJsonSchemaToZodWithRefs', () => {
   });
 });
 
-describe('buildInputsZodValidator', () => {
+describe('buildFieldsZodValidator', () => {
   it('should return empty object schema when schema has no properties', () => {
-    const validator = buildInputsZodValidator(null);
+    const validator = buildFieldsZodValidator(null);
     expect(validator.parse({})).toEqual({});
-    const validator2 = buildInputsZodValidator({});
+    const validator2 = buildFieldsZodValidator({});
     expect(validator2.parse({})).toEqual({});
   });
 
@@ -400,8 +400,8 @@ describe('buildInputsZodValidator', () => {
         age: { type: 'number' },
       },
       required: ['name'],
-    } as Parameters<typeof buildInputsZodValidator>[0];
-    const validator = buildInputsZodValidator(schema);
+    } as Parameters<typeof buildFieldsZodValidator>[0];
+    const validator = buildFieldsZodValidator(schema);
     expect(validator.parse({ name: 'Alice' })).toEqual({ name: 'Alice' });
     expect(validator.parse({ name: 'Bob', age: 30 })).toEqual({ name: 'Bob', age: 30 });
     expect(validator.safeParse({ age: 30 }).success).toBe(false);
@@ -414,8 +414,8 @@ describe('buildInputsZodValidator', () => {
         name: { type: 'string', default: 'unknown' },
         count: { type: 'number', default: 0 },
       },
-    } as Parameters<typeof buildInputsZodValidator>[0];
-    const validator = buildInputsZodValidator(schema);
+    } as Parameters<typeof buildFieldsZodValidator>[0];
+    const validator = buildFieldsZodValidator(schema);
     const result = validator.parse({}) as { name: string; count: number };
     expect(result.name).toBe('unknown');
     expect(result.count).toBe(0);
@@ -427,8 +427,8 @@ describe('buildInputsZodValidator', () => {
       properties: {
         enabled: { type: 'boolean' },
       },
-    } as Parameters<typeof buildInputsZodValidator>[0];
-    const validator = buildInputsZodValidator(schema);
+    } as Parameters<typeof buildFieldsZodValidator>[0];
+    const validator = buildFieldsZodValidator(schema);
     expect(validator.safeParse({ enabled: 'yes' }).success).toBe(false);
     expect(validator.safeParse({ enabled: true }).success).toBe(true);
   });

src/platform/plugins/shared/workflows_management/common/lib/json_schema_to_zod.ts → src/platform/packages/shared/kbn-workflows/spec/lib/build_fields_zod_validator.ts

@@ -8,74 +8,34 @@
  */
 
 import type { JSONSchema7 } from 'json-schema';
-import { resolveRef } from '@kbn/workflows/spec/lib/input_conversion';
 import { z } from '@kbn/zod/v4';
 import { fromJSONSchema } from '@kbn/zod/v4/from_json_schema';
+import { resolveRef } from './field_conversion';
 
 /** Root schema type for $ref resolution (same as resolveRef's second parameter). */
 type RootSchemaType = Parameters<typeof resolveRef>[1];
 
 /**
- * Recursively converts a JSON Schema to a Zod schema
- * This is only used as a fallback for $ref references, which fromJSONSchema doesn't handle
- * For non-$ref schemas, we use fromJSONSchema directly in the main function
+ * Converts a JSON Schema to a Zod schema using fromJSONSchema.
+ * Used as fallback when fromJSONSchema returns undefined or for $ref placeholders.
  */
-function convertJsonSchemaToZodRecursive(jsonSchema: JSONSchema7 | null | undefined): z.ZodType {
-  // Defensive check: handle null/undefined schemas
+export function convertJsonSchemaToZod(jsonSchema: JSONSchema7 | null | undefined): z.ZodType {
   if (!jsonSchema || typeof jsonSchema !== 'object') {
     return z.any();
   }
-
-  // For $ref schemas, we can't use fromJSONSchema directly
-  // Return z.any() as a placeholder - $ref should be resolved before calling this
   if (jsonSchema.$ref) {
     return z.any();
   }
-
-  // Try fromJSONSchema - it handles most cases
   const zodSchema = fromJSONSchema(jsonSchema as Record<string, unknown>);
   if (zodSchema !== undefined) {
     return zodSchema;
   }
-
-  // If fromJSONSchema fails, return z.any() as last resort
-  // This should be rare since fromJSONSchema handles most JSON Schema features
   return z.any();
 }
 
-/**
- * Converts a JSON Schema to a Zod schema using fromJSONSchema polyfill
- * @param jsonSchema - The JSON Schema to convert
- * @returns A Zod schema equivalent to the JSON Schema
- */
-export function convertJsonSchemaToZod(jsonSchema: JSONSchema7 | null | undefined): z.ZodType {
-  // Defensive check: handle null/undefined schemas (crash prevention)
-  if (!jsonSchema || typeof jsonSchema !== 'object') {
-    return z.any();
-  }
-
-  // Note: fromJSONSchema doesn't handle $ref, so we need to resolve them first
-  // For now, if there's a $ref, fall back to recursive converter
-  // TODO: Resolve $ref before calling fromJSONSchema when remote ref support is added
-  if (jsonSchema.$ref) {
-    return convertJsonSchemaToZodRecursive(jsonSchema);
-  }
-
-  // Use fromJSONSchema polyfill - it handles objects, arrays, strings, numbers, booleans,
-  // enums, defaults, required fields, validation constraints, etc.
-  const zodSchema = fromJSONSchema(jsonSchema as Record<string, unknown>);
-  if (zodSchema !== undefined) {
-    return zodSchema;
-  }
-
-  // If fromJSONSchema returns undefined (should be rare), fall back to recursive converter
-  // This is a safety net for edge cases the polyfill might not handle
-  return convertJsonSchemaToZodRecursive(jsonSchema);
-}
-
 /**
  * Recursively converts a JSON Schema to a Zod schema, resolving $ref against the root schema.
- * Use this when you have a root schema (e.g. workflow inputsSchema) and property schemas that may reference it.
+ * Use when you have a root schema (e.g. workflow inputs/outputs) and property schemas that may reference it.
  */
 export function convertJsonSchemaToZodWithRefs(
   jsonSchema: JSONSchema7,
@@ -114,10 +74,11 @@ export function convertJsonSchemaToZodWithRefs(
 }
 
 /**
- * Builds a Zod validator for workflow inputs from a normalized JSON Schema (object with properties, required, etc.).
- * Handles required/optional, defaults, and $ref resolution. Use after normalizeInputsToJsonSchema when validating input payloads.
+ * Builds a Zod validator for workflow fields (inputs or outputs) from a normalized JSON Schema
+ * (object with properties, required, etc.). Handles required/optional, defaults, and $ref resolution.
+ * Use after normalizeFieldsToJsonSchema when validating field payloads.
  */
-export function buildInputsZodValidator(
+export function buildFieldsZodValidator(
   schema: RootSchemaType | null | undefined
 ): z.ZodType<Record<string, unknown>> {
   if (!schema?.properties || typeof schema.properties !== 'object') {