cpee-llm 1.0.0

data/lib/cpee/llm/implementation.rb

@@ -0,0 +1,237 @@
+# This file is part of CPEE-LLM.
+#
+# CPEE-LLM is free software: you can redistribute it and/or modify it under the
+# terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# CPEE-LLM is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with CPEE-LLM (file LICENSE in the main directory). If not, see
+# <http://www.gnu.org/licenses/>.
+
+require 'riddl/server'
+require 'riddl/client'
+require 'xml/smart'
+require 'json'
+require_relative 'functions'
+require_relative 'dataflow'
+
+module CPEE
+
+  module LLM
+
+    SERVER = File.expand_path(File.join(__dir__,'implementation.xml'))
+
+    class CreateMermaid < Riddl::Implementation #{{{
+      include Functions
+      include DataFlow
+
+      def response
+        llms = @a[0]
+        input_cpee  = @p.shift.value.read
+        user_input  = @p.shift.value.read
+        myllm       = @p.shift.value.read
+        prompt_type = @p.shift.value.read if @p[0]&.name == 'prompt_type'
+        endpoints   = @p.shift.value.read if @p[0]&.name == 'endpoints'
+        temperature = @p.shift.value.read if @p[0]&.name == 'temperature'
+
+        doc = XML::Smart.string(input_cpee)
+        pp temperature
+        begin
+          output_cpee = if prompt_type == 'generate_noendpoints'
+            llm_response = generate_model(myllm,user_input,temperature,llms)
+            mermaid_to_cpee(llm_response)
+          elsif prompt_type == 'generate_endpoints'
+            # get endpoints (hardcoded for demo, in future separate step)
+            llm_response = generate_endpoint_model(myllm,user_input,get_demo_endpoints(),llms)
+            mermaid_to_cpee(llm_response)
+          elsif prompt_type == 'adapt_noendpoints'
+            llm_response = adapt_model(myllm,doc,user_input,llms)
+            mermaid_to_cpee(llm_response)
+          elsif prompt_type == 'adapt_endpoints'
+            xml_endpoints = XML::Smart.string(endpoints)
+            adapt_cpee_model(myllm,doc,user_input,xml_endpoints,get_demo_endpoints(),llms)
+          end
+        rescue Exception => e
+          @status = 500
+          return Riddl::Parameter::Complex.new('llm_out', 'application/json', { error: e }.to_json)
+        end
+
+        return(Riddl::Parameter::Complex.new("llm_out","application/json",{:user_input => user_input, :used_llm => myllm, :input_cpee => input_cpee, :input_intermediate => doc.root().empty?() ? "" : cpee_to_mermaid(doc.to_s()), :output_intermediate => llm_response, :output_cpee => output_cpee, :status => "Success"}.to_json()))
+      rescue LLMError => e
+        pp 'here in error'
+        @status = e&.http_response || 400
+        return Riddl::Parameter::Complex.new("llm_out","application/json",{ :error => "#{prompt_type} #{e.message}"}.to_json())
+      end
+    end #}}}
+
+    class CreateText < Riddl::Implementation #{{{
+      include Functions
+
+      def response
+        llms = @a[0]
+        input_cpee  = @p.shift.value.read
+        begin
+          input_cpee = @p[0].value.read
+          myllm = @p[1].value
+          doc = XML::Smart.string(input_cpee)
+        rescue Exception => e
+          @status = 400
+          return Riddl::Parameter::Complex.new('llm_out','application/json',{:error => e}.to_json())
+        end
+
+        if doc.root.empty?
+          @status = 400
+          return Riddl::Parameter::Complex.new('text_out','application/json',{:error => e}.to_json())
+        else
+          begin
+            llm_response = generate_text(myllm,doc,llms)
+          rescue LLMError => e
+            @status = e.http_response
+            return Riddl::Parameter::Complex.new('text_out','application/json',{:error => e.message}.to_json())
+          end
+        end
+        begin
+          output_cpee = mermaid_to_cpee(llm_response)
+        rescue Exception => e
+          @status = 500
+          return Riddl::Parameter::Complex.new('text_out','application/json',{:error => e}.to_json())
+        end
+
+        return(Riddl::Parameter::Complex.new("text_out","application/json",{:input_cpee => input_cpee, :input_intermediate => doc.root.empty? ? '' : cpee_to_mermaid(doc.to_s), :output_text => llm_response, :status => 'Success'}.to_json()))
+      end
+    end #}}}
+
+    class CreateGeneric < Riddl::Implementation #{{{
+      include Functions
+
+      def response
+        llms = @a[0]
+        #get parameters
+        begin
+          myllm = @p[0].value.read
+          user_input = @p[1].value.read
+          system_prompt = @p[2].value.read
+          format = @p[3].value.read
+          temperature = @p[4]&.value&.read
+        rescue Exception => e
+          @status = 400
+          return Riddl::Parameter::Complex.new("generic_out","application/json",{:error => e}.to_json())
+        end
+
+        begin
+          llm_response = generate_generic(myllm,user_input,system_prompt,format,temperature,llms)
+        rescue LLMError => e
+          @status = e.http_response
+          return Riddl::Parameter::Complex.new("generic_out","application/json",{:error => e.message}.to_json())
+        end
+
+        return(Riddl::Parameter::Complex.new("generic_out","application/json",{:user_input => user_input, :used_llm => myllm, :system_prompt => system_prompt, :llm_response => llm_response, :status => "Success"}.to_json()))
+      end
+    end #}}}
+
+    class CreateDataFlow < Riddl::Implementation #{{{
+      include Functions
+      include DataFlow
+
+      def response
+        llms = @a[0]
+
+        #get parameters
+        begin
+          input_cpee = @p[0].value().read()
+          myllm = @p[1].value().read()
+          doc = XML::Smart.string(input_cpee)
+        rescue Exception => e
+          @status = 400
+          return Riddl::Parameter::Complex.new("llm_out","application/json",{:error => e}.to_json())
+        end
+        begin
+          mermaid_model = cpee_to_mermaid(doc.to_s())
+          #get endpoints (hardcoded for demo, in future separate step)
+          endpoints_description = get_demo_endpoints()
+          #match tasks and endpoints
+          api_speck = get_matching_endpoints(doc,endpoints_description)
+        rescue Exception => e
+          @status = 500
+          return Riddl::Parameter::Complex.new('llm_out', 'application/json', { error: e }.to_json)
+        end
+
+        #generate data flow
+        begin
+          dataflow = generate_dataflow(myllm,mermaid_model,api_speck,llms)
+        rescue LLMError => e
+          pp e.http_response
+          @status = e.http_response || 400
+          return Riddl::Parameter::Complex.new("llm_out","application/json",{:error => e.message}.to_json())
+        end
+
+        #integrate dataflow in cpee_model
+        final_cpee, endpoints = integrate_dataflow(doc,dataflow)
+
+        return(Riddl::Parameter::Complex.new("llm_out","application/json",{:used_llm => myllm, :dataflow => dataflow, :output_cpee => final_cpee, :endpoints => endpoints, :status => "Success"}.to_json()))
+      end
+    end #}}}
+
+    class ValidateDataFlow < Riddl::Implementation #{{{
+      include Functions
+
+      def response
+        llms = @a[0]
+
+        #get parameters
+        begin
+          input_cpee = @p[0].value().read()
+          myllm = @p[1].value().read()
+          doc = XML::Smart.string(input_cpee)
+        rescue Exception => e
+          @status = 400
+          return Riddl::Parameter::Complex.new("llm_out","application/json",{:error => e}.to_json())
+        end
+
+        begin
+          llm_response = validate_cpee_model(myllm,input_cpee,llms)
+        rescue LLMError => e
+          @status = e.http_response
+          return Riddl::Parameter::Complex.new("generic_out","application/json",{:error => e.message}.to_json())
+        end
+
+        return(Riddl::Parameter::Complex.new("llm_out","application/json",{:used_llm => myllm, :output_cpee => llm_response, :status => "Success"}.to_json()))
+      end
+    end #}}}
+
+    def self::implementation(opts)
+      Proc.new do
+        on resource do
+          run(CreateMermaid, opts[:llms]) if post 'llm_in'
+
+          on resource 'dataflow' do
+            run(CreateDataFlow, opts[:llms]) if post 'dataflow_in'
+          end
+
+          on resource 'validate' do
+            on resource 'xml' do
+              run(ValidateDataFlow, opts[:llms]) if post 'dataflow_in'
+            end
+          end
+
+          on resource 'text' do
+            on resource 'llm' do
+              run(CreateText, opts[:llms]) if post 'text_in'
+            end
+          end
+
+          on resource 'generic' do
+            run(CreateGeneric, opts[:llms]) if post 'generic_in'
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/cpee/llm/implementation.xml

@@ -0,0 +1,90 @@
+<!--
+  This file is part of CPEE-LLM.
+
+  CPEE-LLM is free software: you can redistribute it and/or modify it under the
+  terms of the GNU General Public License as published by the Free Software
+  Foundation, either version 3 of the License, or (at your option) any later
+  version.
+
+  CPEE-LLM is distributed in the hope that it will be useful, but WITHOUT ANY
+  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+  A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License along with
+  CPEE-LLM (file LICENSE in the main directory). If not, see
+  <http://www.gnu.org/licenses/>.
+-->
+
+<description datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes" xmlns="http://riddl.org/ns/description/1.0" xmlns:xi="http://www.w3.org/2001/XInclude">
+
+  <message name="llm_in">
+    <parameter name="rpst_xml" mimetype="text/xml"/>
+    <parameter name="user_input" mimetype="text/plain"/>
+    <parameter name="llm" mimetype="text/plain"/>
+    <optional>
+      <parameter name="prompt_type" mimetype="text/plain"/>
+    </optional>
+    <optional>
+      <parameter name="endpoints" mimetype="text/xml"/>
+    </optional>
+    <optional>
+      <parameter name="temperature" mimetype="text/plain"/>
+    </optional>
+  </message>
+  <message name="llm_out">
+    <parameter name="rpst_xml" mimetype="application/json"/>
+  </message>
+
+  <message name="text_in">
+    <parameter name="rpst_xml" mimetype="*/xml"/>
+    <parameter name="llm" type="string"/>
+  </message>
+  <message name="text_out">
+    <parameter name="output_text" mimetype="application/json"/>
+  </message>
+
+  <message name="generic_in">
+    <parameter name="llm" mimetype="text/plain"/>
+    <parameter name="user_input" mimetype="text/plain"/>
+    <parameter name="system_prompt" mimetype="text/plain"/>
+    <parameter name="format" mimetype="text/plain"/>
+    <optional>
+      <parameter name="temperature" mimetype="text/plain"/>
+    </optional>
+  </message>
+  <message name="generic_out">
+    <parameter name="output_text" mimetype="application/json"/>
+  </message>
+
+  <message name="dataflow_in">
+    <parameter name="rpst_xml" mimetype="text/xml"/>
+    <parameter name="llm" mimetype="text/plain"/>
+  </message>
+
+  <resource>
+    <post in="llm_in" out="llm_out"/>
+
+    <resource relative="dataflow">
+      <post in="dataflow_in" out="llm_out"/>
+    </resource>
+
+    <resource relative="text">
+      <resource relative="llm">
+        <post in="text_in" out="text_out"/>
+      </resource>
+    </resource>
+
+    <resource relative="generic">
+      <post in="generic_in" out="generic_out"/>
+    </resource>
+
+    <resource relative="validate">
+      <resource relative="xml">
+        <post in="dataflow_in" out="llm_out"/>
+      </resource>
+    </resource>
+
+  </resource>
+
+</description>
+

data/lib/cpee/llm/prompts/adapt_xml.txt

@@ -0,0 +1,157 @@
+You are an expert BPMN 2.0 process model editor for the CPEE XML process description language.
+Your task is to modify an existing CPEE XML process model according to the user's natural-language modification request.
+The user will always provide:
+* an existing valid CPEE XML process model;
+* one or more textual modification requests;
+* a list of available API endpoints (service registry).
+
+Service Registry maps each task label to one service specification. Each service specification includes:
+  - service url
+  - service description
+  - service functionality
+  - input (RelaxNG schema)
+  - optional output
+
+Core Objective
+Your task is to produce a modified CPEE XML process model that implements the requested changes.
+Only modify the parts of the process that are explicitly or necessarily affected by the user's request.
+Do not redesign, simplify, optimize, refactor, or rewrite unrelated parts of the model.
+Never remove existing functionality unless explicitly requested.
+Never introduce additional behavior that was not requested.
+
+Editing Workflow
+Internally perform the following steps:
+1. Parse the existing CPEE XML testset.
+2. Parse the endpoint definitions.
+3. Parse the workflow contained in the description element.
+4. Understand the user's requested modifications.
+5. Determine which workflow elements and endpoint definitions are affected.
+6. Apply only the requested changes.
+7. Update data flow if necessary.
+8. Generate the complete updated CPEE XML testset.
+
+CPEE XML Testset Structure
+The input CPEE XML document has the following structure:
+  - The root element is <testset>.
+  - <endpoints> contains the mapping from endpoint names to service URLs.
+  - <dslx> contains the workflow definition.
+  - The actual process model is the <description> element inside <dslx>.
+
+#Endpoint Handling
+The <endpoints> section defines all available service endpoints.
+Each endpoint consists of the endpoint name (the XML element name), and the corresponding service URL (the element value).
+Service tasks inside the workflow reference endpoints only by endpoint name, for example:
+<call endpoint="measurewaterlevel">
+Endpoint Rules:
+  - <call endpoint="..."> always references an endpoint name.
+  - URLs are stored only in <endpoints>.
+  - Update URLs in <endpoints>; update endpoint attributes only when the endpoint name changes.
+  - Do not modify unrelated endpoints.
+
+# Service Registry Usage for Newly Added Tasks
+When the user's modification request introduces one or more new tasks, first determine whether the task exists in the Service Registry.
+If the task exists in the Service Registry:
+- Create a <call> element using the corresponding service specification.
+- Set the endpoint attribute to the endpoint defined for the service.
+- If the endpoint is not already present in the <endpoints> section, add it using the URL from the Service Registry.
+- Define the task according to the service specification.
+- Define the <arguments> section with the required input parameters, assigning values from the existing process context whenever possible.
+- If the service specification defines outputs, generate the appropriate <finalize> code to store the returned values in workflow variables (data.*) for later use.
+- Integrate the task into the existing workflow without modifying unrelated behavior.
+If the task does not exist in the Service Registry:
+- Create an empty <call> element as a placeholder.
+- Do not invent an endpoint, service URL, input parameters, output mappings, or implementation details.
+- Leave the task unconfigured except for information explicitly requested by the user.
+Always use the Service Registry whenever a matching service specification is available.
+
+# CPEE XML Process Model Structure
+The process model itself is contained entirely inside the <description> element. Interpret the XML inside <description> using the following mapping.
+## Sequential Flow
+Sequential execution is represented by sibling XML elements appearing in order inside the same parent element.
+
+## Service Task
+A BPMN Service Task is represented by a `<call>` element.
+The endpoint of the service is stored in the **endpoint attribute**.
+<call endpoint="measurelightingconditions">
+The following child elements may appear inside `<call>`:
+├── parameters
+│   ├── label
+│   ├── method
+│   └── arguments
+├── code
+│   ├── signal
+│   ├── prepare
+│   ├── finalize
+│   ├── update
+│   └── rescue
+├── annotations
+└── documentation
+
+The <method> field must strictly follow the Service Registry specification.
+If the service specification defines a method, use exactly that value. The value must always be lowercase and enclosed in colons (example: <method>:get</method>).
+Never invent, infer, or assume a method value that is not explicitly defined in the service specification:
+<method/>
+
+Service input parameters are stored inside arguments. Each argument is represented by its own child element.
+<arguments>
+    <min>1</min>
+    <max>100</max>
+</arguments>
+If an argument depends on a previously computed or returned value, it must be provided using the !data.some_value syntax.
+<arguments>
+    <step>!data.current_step</step>
+</arguments>
+
+Returned service values are processed inside finalize: <finalize output="result">, where result is the variable containing the service response. Assign values from result (for example, result["start"] or result["end"]) to workflow variables (for example, data.start or data.end) to store them for later use in the process.
+<finalize output="result"> data.temperature = result["temperature"].to_f; data.type = result["celsius"];</finalize>
+
+## Script Task
+A BPMN Script Task is represented by <manipulate>.  The executable Ruby code is stored inside the <code> child element:
+<manipulate><code>data.counter += 1</code></manipulate>
+
+## Exclusive Gateway
+An Exclusive Gateway is represented by <choose>
+Each outgoing branch is represented by <alternative> child.
+The branch condition is stored in the **condition attribute**.
+<alternative condition="data.temperature > 30">
+Conditions must be valid Ruby expressions.
+
+## Loop
+A BPMN loop is represented by <loop>
+The loop condition is stored in the **condition attribute**. The loop execution mode is stored in the **mode attribute** (pre_test/post_test)
+<loop mode="pre_test" condition="data.counter < 10">
+Loop conditions must be valid Ruby expressions.
+
+## Parallel Gateway
+Parallel execution is represented by <parallel>
+Each concurrent branch is represented by <parallel_branch>
+
+##Pause Task
+A pause is represented by a <stop> element.
+A <stop> pauses the execution of the process (until it is manually resumed). It does not terminate the process.
+<stop id="a5"/>
+When the user requests to pause, hold, or stop the process, insert a <stop> element.
+The id attribute must be unique within the process model. The id must follow the same naming convention as the existing element IDs in the process model.
+Insert the <stop> element at the location specified or implied by the user's request. Otherwise, insert the <stop> element as the last element of the process.
+
+## Variables
+Variables are referenced as: data.variable_name
+Service outputs are returned as strings unless otherwise specified.
+Whenever a value represents a numeric type (integer or floating-point), convert it to a numeric value before assigning it to a workflow variable by using Ruby's .to_f method:
+data.temperature = result["temperature"].to_f
+
+# Handling Ambiguity
+If the user's request is sufficiently precise, perform the modification directly.
+If multiple valid interpretations exist and the missing information affects the resulting workflow, select the best possible interpretation and perform changes.
+
+# Output Requirements
+  Return the complete updated CPEE XML process model.
+  Preserve the overall document structure (testset, endpoints, dslx, and description).
+  Modify only the elements affected by the user's request.
+  Return the entire XML document, including unchanged sections.
+  Do not explain the modifications.
+  Do not summarize the changes.
+  Do not output Markdown.
+  Do not omit unchanged sections.
+  The returned XML must be immediately usable as a valid CPEE process model.
+

data/lib/cpee/llm/prompts/apply.txt

@@ -0,0 +1,32 @@
+You are an expert in BPMN modeling, specifically in Mermaid.js format.
+Your task is to validate and transform BPMN models based on user-provided modifications, ensuring compliance with BPMN rules and Mermaid.js syntax.
+You are allowed to adjust only those parts of the process model mentioned in the user-provided modification. Other parts of the model have to stay unchanged.
+The Mermaid.js syntax for BPMN models is described as follows:
+The graph must use the LR (Left to Right) direction.
+Each mermaid js node must have the following structure:
+id:type:shape and text
+    id - it is a unique identifier. Id can be only an integer from 0 to n. Each node has a unique identifier
+    type - defines the type of the element regarding to BPMN 2.0 notation.
+        possible types are: start event, end event, task, subprocess, exclusive, inclusive and parallel gateway.
+        Based on the type of the node following shapes and texts are to be used:
+        startevent: ((startevent))      i.e., id:startevent:((startevent))
+        endevent: (((endevent)))        i.e., id:endevent:(((endevent)))
+        task: (task label)              i.e., id:task:(task label)
+        subprocess: (subprocess label)  i.e., id:subprocess:(subprocess label)
+        exclusivegateway: {x}           i.e., id:exclusivegateway:{x}
+        parallelgateway: {AND}          i.e., id:parallelgateway:{AND}
+        inclusivegateway: {O}           i.e., id:inclusivegateway:{O}
+
+All gateways must have both a split and a merge point.
+Each gateway that initiates a split must be properly closed by a merge gateway of the same type (e.g., an exclusive gateway must be merged by another exclusive gateway).
+
+All nodes that have occurred more than once should have following structure: id:type: (i.e., 2:task: ) by futher occurrence.
+It is strictly prohibited to use only id (i.e. 2) as a reference.
+
+All elements are connected with each other with the help of the direction.
+    direction: -->
+If there are some conditions or annotations it is necessary to use text on links (i.e., edge labels)
+    edge label: |condition or annotation|
+Edge label is always located between 2 nodes: id:exclusivegateway:{x} --> |condition or annotation|id:task:(task label)
+
+Return only mermaid.js as text without any additional information! Give me just the raw Mermaid.js code without markdown formatting.