Start working on ScenarioProcessed

Author: InAnYan

module/move/assistant/src/agents.rs

@@ -11,5 +11,6 @@ crate::mod_interface!
   layer context;
   layer scenario_raw;
   layer scenario_raw_processors;
+  layer scenario_processed;
 
 }

module/move/assistant/src/agents/path.rs

@@ -12,6 +12,12 @@ mod private
     sync::LazyLock,
   };
 
+  use serde::
+  {
+    Serialize,
+    Deserialize,
+  };
+
   use regex::Regex;
 
   /// Path separator string.
@@ -41,7 +47,7 @@ mod private
   ///
   /// Paths resemble filesystem path, path separator is `::`.
   /// Absolute path starts with `::`.
-  #[ derive( Debug, Clone, Eq, PartialEq, Hash ) ]
+  #[ derive( Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize ) ]
   pub struct Path( String );
 
   impl Path

module/move/assistant/src/agents/scenario_processed.rs

@@ -0,0 +1,157 @@
+//!
+//! Scenario representation. Stores parsed representation of templates and paths.
+//! This is the type used for running scenarios.
+//!
+//! For a more simplistic representation use `ScenarioRaw`.
+//!
+
+mod private
+{
+  use serde::
+  {
+    Serialize,
+    Deserialize,
+  };
+
+  use crate::*;
+  use agents::
+  {
+    path::Path,
+    scenario_raw::ScenarioRaw,
+  };
+
+  /// New type for templates in scenarios.
+  #[ derive( Debug, Serialize, Deserialize, PartialEq ) ]
+  pub struct TemplateBody( pub String );
+
+  /// Struct that represents user written scenarios.
+  ///
+  /// This is a processed form of a scenario, templates and paths are distinguished here with types.
+  /// For more simplistic representation of scenarios, use `ScenarioRaw` type.
+  #[ derive( Debug, Serialize, Deserialize, PartialEq ) ]
+  pub struct ScenarioProcessed
+  {
+    /// Nodes in the scenario.
+    pub nodes: Vec< Node >,
+  }
+
+  impl TryFrom< ScenarioRaw > for ScenarioProcessed
+  {
+    type Error = std::io::Error;
+
+    fn try_from( scenario_raw : ScenarioRaw ) -> Result< Self, Self::Error >
+    {
+      let nodes : Result< Vec< Node >, Self::Error > = scenario_raw.nodes.into_iter().map( | n | n.try_from() ).collect();
+      
+      Ok( Self { nodes } )
+    }
+  }
+
+  /// Node representation in a scenario file.
+  ///
+  /// This is a processed form of a node, templates and paths are distinguished here with types.
+  /// For more simplistic representation of scenarios, use `NodeRaw` type.
+  #[ derive( Debug, Serialize, Deserialize, PartialEq ) ]
+  pub struct Node
+  {
+    /// ID of the node. Must be unique, will also identify node output. 
+    pub id : String,
+
+    /// Type of the node.
+    pub r#type : Path,
+
+    /// Specific type of `Node`.
+    pub kind : NodeKind,
+
+    /// ID of the next node to execute.
+    pub next : Path,
+  }
+
+  impl TryFrom< NodeRaw > for Node
+  {
+    type Error = std::io::Error;
+
+    fn try_form( node_raw : NodeRaw ) -> Result< Self, Self::Error >
+    {
+      Ok
+      (
+        Self
+        {
+          id : node_raw.id,
+          r#type : Path::try_from( node_raw.r#type )?,
+          kind : NodeKind::try_from( node_raw.params )?,
+          next : Path::try_from( node_raw.path )?,
+        }
+      )
+    }
+  }
+
+  /// Representation of different types of nodes. Contains parameters unique to types.
+  /// Used in `Node` struct, where you can find common parameters like `id`, `type`, and others.
+  #[ derive( Debug, Serialize, Deserialize, PartialEq ) ]
+  pub enum NodeKind
+  {
+    /// Read input from `stdin`.
+    TriggerStdin
+    {
+      /// Prompt to display to `stdout` before reading the `stdin`.
+      prompt : TemplateBody,
+    },
+
+    /// Get output from LLM.
+    AgentsCompletion
+    {
+      /// Agent's system message template.
+      system_message : TemplateBody,
+      /// Agent's user message template.
+      user_message : TemplateBody,
+      /// Reuse chat history of other agent.
+      agent_reuse : Path,
+    },
+
+    /// Print output to `stdout`.
+    EventStdout
+    {
+      /// Prompt to display to `stdout`.
+      output : TemplateBody,
+    },
+  }
+
+  impl NodeKind
+  {
+    /// Convert `NodeRaw` into `NodeKind`.
+    pub fn try_from_params
+    (
+      params : HashMap< String, String >,
+      r#type : &Path,
+    ) -> Result< Self, std::io::Error >
+    {
+      match path.inner().as_str()
+      {
+        "::trigger::stdin" =>
+        {
+          let Some()
+        }
+      }
+    }
+  }
+
+  impl TryFrom< HashMap< String, String > > for NodeKind
+  {
+    type Error = std::io::Error;
+
+    fn try_from( map : HashMap< String, String> ) -> Result< Self, Self::Error >
+    {
+      
+    }
+  }
+}
+
+crate::mod_interface!
+{
+  own use
+  {
+    TemplateBody,
+    ScenarioProcessed,
+  };
+}

module/move/assistant/src/agents/scenario_raw.rs

@@ -6,17 +6,13 @@
 
 mod private
 {
-  use std::
-  {
-    io,
-    collections::HashMap,
-  };
+  use std::io;
 
   use former::Former;
   use serde::
   {
-    Serialize,
-    Deserialize,
+    serialize,
+    deserialize,
   };
 
   /// Struct that represents user written scenarios.
@@ -49,16 +45,173 @@ mod private
     /// ID of the node. Must be unique, will also identify node output. 
     pub id : String,
 
-    /// Type of the node. Represented as a path.
+    /// Type of the node.
     pub r#type : String,
 
-    /// Rest of the key-value pairs in the node that are specific to node types.
-    #[ serde( flatten ) ]
-    pub params : HashMap< String, String >,
+    /// Specific type of `NodeRaw`.
+    pub kind : NodeRawKind,
 
-    /// ID of the next node to execute. Represented as a path.
+    /// ID of the next node to execute.
     pub next : String,
   }
+
+  impl format_tools::Fields< &'_ str, &'_ str > for NodeRaw
+  {
+    type Key< 'k > = &'k str;
+    type Val< 'v > = &'v str;
+
+    fn fields( &self ) -> impl format_tools::IteratorTrait< Item = ( &'_ str, &'_ str ) >
+    {
+      let mut dst = Vec::new();
+
+      dst.push( ( "id", self.id.as_str() ) );
+      dst.push( ( "type", self.r#type.as_str() ) );
+
+      dst.extend( self.kind.fields() );
+
+      dst.push( ( "next", self.next.as_str() ) );
+
+      dst.into_iter()
+    }
+  }
+
+  /// Representation of different types of nodes. Contains parameters unique to types.
+  /// Used in `Node` struct, where you can find common parameters like `id`, `type`, and others.
+  #[ derive( Debug, Serialize, Deserialize, PartialEq ) ]
+  pub enum NodeRawKind
+  {
+    /// Read input from `stdin`.
+    TriggerStdin( TriggerStdinRaw ),
+
+    /// Get output from LLM.
+    AgentsCompletion( AgentsCompletionRaw ),
+
+    /// Print output to `stdout`.
+    EventStdout( EventStdoutRaw ),
+  }
+
+  impl format_tools::Fields< &'_ str, &'_ str > for NodeRawKind
+  {
+    type Key< 'k > = &'k str;
+    type Val< 'v > = &'v str;
+
+    fn fields( &self ) -> impl format_tools::IteratorTrait< Item = ( &'_ str, &'_ str ) >
+    {
+      match self
+      {
+        Self::TriggerStdin( v ) => v.fields(),
+        Self::AgentsCompletion( v ) => v.fields(),
+        Self::EventStdout( v ) => v.fields(),
+      }
+    }
+  }
+
+  /// Read input from `stdin`.
+  #[ derive( Debug, Serialize, Deserialize, Former, PartialEq ) ]
+  pub struct TriggerStdinRaw
+  {
+    pub prompt : String;
+  }
+
+  impl From< TriggerStdinRaw > for NodeRawKind
+  {
+    fn from( value : TriggerStdinRaw ) -> Self
+    {
+      Self::TriggerStdin( value )
+    }
+  }
+
+  impl format_tools::Fields< &'_ str, &'_ str > for TriggerStdinRaw
+  {
+    type Key< 'k > = &'k str;
+    type Val< 'v > = &'v str;
+
+    fn fields( &self ) -> impl format_tools::IteratorTrait< Item = ( &'_ str, &'_ str ) >
+    {
+      std::iter::once( ( "prompt", prompt.as_str() ) )
+    }
+  }
+
+  /// Get output from LLM.
+  #[ derive( Debug, Serialize, Deserialize, Former, PartialEq ) ]
+  pub struct AgentsCompletionRaw
+  {
+    /// Agent's system message template.
+    pub system_message : String,
+
+    /// Agent's user message template.
+    pub user_message : String,
+
+    /// Reuse chat history of other agent.
+    pub agent_reuse : Option< String >,
+  }
+
+  impl From< AgentsCompletionRaw > for NodeRawKind
+  {
+    fn from( value : AgentsCompletionRaw ) -> Self
+    {
+      Self::AgentsCompletion( value )
+    }
+  }
+
+  impl format_tools::Fields< &'_ str, &'_ str > for AgentsCompletionRaw
+  {
+    type Key< 'k > = &'k str;
+    type Val< 'v > = &'v str;
+
+    fn fields( &self ) -> impl format_tools::IteratorTrait< Item = ( &'_ str, &'_ str ) >
+    {
+      let mut dst = Vec::new();
+
+      dst.push( ( "system_message", system_message.as_str() ) );
+      dst.push( ( "user_message", user_message.as_str() ) );
+
+      if let Some( agent_reuse ) = agent_reuse
+      {
+        dst.push( ( "agent_reuse", agent_reuse.as_str() ) );
+      }
+
+      dst.into_iter()
+    }
+  }
+
+  /// Print output to `stdout`.
+  #[ derive( Debug, Serialize, Deserialize, Former, PartialEq ) ]
+  pub struct EventStdoutRaw
+  {
+    /// Prompt to display to `stdout`.
+    pub output : String,
+  }
+
+  impl From< EventsStdoutRaw > for NodeRawKind
+  {
+    fn from( value : EventsStdoutRaw ) -> Self
+    {
+      Self::EventsStdout( value )
+    }
+  }
+
+  impl format_tools::Fields< &'_ str, &'_ str > for EventStdoutRaw
+  {
+    type Key< 'k > = &'k str;
+    type Val< 'v > = &'v str;
+
+    fn fields( &self ) -> impl format_tools::IteratorTrait< Item = ( &'_ str, &'_ str ) >
+    {
+      let mut dst = Vec::new();
+
+      dst.push( ( "system_message", system_message.as_str() ) );
+      dst.push( ( "user_message", user_message.as_str() ) );
+
+      if let Some( agent_reuse ) = agent_reuse
+      {
+        dst.push( ( "agent_reuse", agent_reuse.as_str() ) );
+      }
+
+      dst.into_iter()
+    }
+  }
+
 }
 
 crate::mod_interface!
@@ -67,5 +220,6 @@ crate::mod_interface!
   {
     ScenarioRaw,
     NodeRaw,
+    NodeRawKind,
   };
 }